Ersten Cluster in Virtual Private Cloud (VPC) einrichten

Sie können einen IBM Cloud® Kubernetes Service-Cluster in Ihrer Virtual Private Cloud-Umgebung (VPC-Umgebung) erstellen.

Mit IBM Cloud Kubernetes Service-Clustern auf VPC können Sie Ihren Cluster auf der nächsten Generation der IBM Cloud-Plattform in Ihrer Virtual Private Cloud erstellen. Die VPC gibt Ihnen die Sicherheit einer privaten Cloudumgebung mit der dynamischen Skalierbarkeit einer öffentlichen Cloud. VPC verwendet die nächste Version von IBM Cloud Kubernetes Service-Infrastrukturprovidern mit einer ausgewählten Gruppe von API-, CLI- und Konsolenfunktionen der Version 2. Sie können nur Standardcluster für VPC erstellen.

Zielgruppe

Dieses Lernprogramm ist für Administratoren gedacht, die zum ersten Mal einen Cluster in IBM Cloud Kubernetes Service in einer VPC-Instanz erstellen.

Ziele

In den Lerneinheiten des Lernprogramms erstellen Sie einen IBM Cloud Kubernetes Service-Cluster in einer Virtual Private Cloud-Umgebung (VPC). Anschließend stellen Sie eine App bereit und machen die App mithilfe einer Lastausgleichsfunktion öffentlich zugänglich.

Was Sie erhalten

In diesem Tutorial erstellen Sie die folgenden Ressourcen. Es gibt optionale Schritte zum Löschen dieser Ressourcen, wenn Sie sie nach dem Durcharbeiten des Lernprogramms nicht beibehalten möchten.

Ein VPC-Cluster
Eine einfache Hello World-App, die in Ihrem Cluster bereitgestellt wird
Eine VPC-Lastausgleichsfunktion zum Verfügbarmachen Ihrer App

Voraussetzungen

Führen Sie die folgenden vorausgesetzten Schritte aus, um die Berechtigungen und die Befehlszeilenumgebung einzurichten.

Berechtigungen: Wenn Sie der Kontoinhaber sind, verfügen Sie bereits über die erforderlichen Berechtigungen zum Erstellen eines Clusters und können mit dem nächsten Schritt fortfahren. Andernfalls wenden Sie sich an den Kontoeigner, um den API-Schlüssel einrichten und sich die mindestens erforderlichen Benutzerberechtigungen in IBM Cloud IAM zuweisen zu lassen.
Befehlszeilentools: Für einen schnellen Zugriff auf Ihre Ressourcen über die Befehlszeile verwenden Sie IBM Cloud Shell. Alternativ können Sie Ihre lokale Befehlszeilenumgebung durch die folgenden Schritte einrichten.

Installieren Sie die IBM Cloud-CLI (ibmcloud), das Kubernetes Service-Plug-in (ibmcloud ks) und das IBM Cloud Container Registry-Plug-in (ibmcloud cr).
Installieren Sie die Befehlszeilenschnittstellen (CLIs) für Red Hat OpenShift (oc) und Kubernetes (kubectl).
Zur Arbeit mit VPC installieren Sie das Plug-in infrastructure-service. Das Präfix für die Ausführung von Befehlen ist ibmcloud is.
```
ibmcloud plugin install infrastructure-service
```
Aktualisieren Sie Ihr Kubernetes Service-Plug-in auf die neueste Version.
```
ibmcloud plugin update kubernetes-service
```
Stellen Sie sicher, dass die kubectl-Version der Kubernetes-Version Ihres VPC-Clusters entspricht. In diesem Tutorial wird ein Cluster erstellt, auf dem die Version 1.35 ausgeführt wird.

Cluster in VPC erstellen

Erstellen Sie einen IBM Cloud Kubernetes Service-Cluster in Ihrer IBM Cloud Virtual Private Cloud-Umgebung (VPC-Umgebung). Weitere Informationen zu VPC enthält die Einführung in Virtual Private Cloud.

Melden Sie sich bei dem Konto sowie der Ressourcengruppe und der IBM Cloud-Region an, in der Ihre VPC-Umgebung erstellt werden soll. Die VPC muss in derselben Multizonen-Metropolregion eingerichtet werden, in der Sie Ihren Cluster erstellen möchten. In diesem Lernprogramm erstellen Sie eine VPC in der Region us-south (USA - Süden). Informationen zu anderen unterstützten Regionen finden Sie unter Mehrzonen-Metropolen für VPC-Cluster. Wenn Sie über eine föderierte ID verfügen, geben Sie die Option --sso an.
```
ibmcloud login -r us-south [-g <resource_group>] [--sso]
```

Erstellen Sie eine VPC für Ihren Cluster. Weitere Informationen finden Sie in der Dokumentation zur Erstellung einer VPC in der Konsole oder in der Befehlszeilenschnittstelle (CLI).

Erstellen Sie eine VPC mit dem Namen myvpc und notieren Sie die ID in der Ausgabe. VPCs stellen eine isolierte Umgebung für Ihre Workloads für die Ausführung in der öffentlichen Cloud bereit. Sie können dieselbe VPC für mehrere Cluster verwenden, zum Beispiel wenn Sie planen, auf verschiedenen Clustern separate Microservices bereitzustellen, die miteinander kommunizieren müssen. Wenn Sie Ihre Cluster voneinander trennen möchten, zum Beispiel für verschiedene Abteilungen, können Sie eine VPC für jeden Cluster erstellen.

    ibmcloud is vpc-create myvpc
    ```
2. Erstellen Sie ein Teilnetz für Ihre VPC und notieren Sie die **ID** des Teilnetzes. Berücksichtigen Sie bei der Erstellung des VPC-Teilnetzes die folgenden Informationen:
    - **Zonen:** Sie müssen jeweils ein VPC-Teilnetz für jede Zone in Ihrem Cluster erstellen. Die verfügbaren Zonen hängen von der Metropolregion ab, in der Sie die VPC erstellt haben. Führen Sie zum Auflisten der verfügbaren Zonen in der Region den Befehl `ibmcloud is zones` aus.
    - **IP-Adressen**: VPC-Teilnetze stellen private IP-Adressen für Ihre Workerknoten und Services für Lastausgleichsfunktionen in Ihrem Cluster bereit. Daher müssen Sie ein [Teilnetz mit einer ausreichenden Anzahl an IP-Adressen erstellen](/docs/containers?topic=containers-vpc-subnets#vpc_basics_subnets), beispielsweise 256. Sie können die Anzahl der IP-Adressen, die in einem VPC-Teilnetz verwendet werden, später nicht mehr ändern.
    - **Öffentliche Gateways**: Sie müssen kein öffentliches Gateway anhängen, um dieses Lernprogramm abzuschließen. Stattdessen können Sie Ihre Workerknoten vom öffentlichen Zugriff isoliert halten, indem Sie VPC-Lastausgleichsfunktionen verwenden, um Workload sicher zugänglich zu machen. Sie könnten ein öffentliches Gateway zuordnen, wenn Ihre Workerknoten auf eine öffentliche URL zugreifen müssen.

```sh {: pre}
    ibmcloud is subnet-create mysubnet1 VPC_ID --zone us-south-1 --ipv4-address-count 256
    ```

Erstellen Sie einen Cluster in Ihrer VPC in derselben Zone wie das Teilnetz. Ihr Cluster wird standardmäßig mit einem Public- und einem Private-Cloud-Serviceendpunkt erstellt. Sie können den Public-Cloud-Serviceendpunkt auf Ihrer lokalen Maschine für den Zugriff auf den Kubernetes-Master verwenden, zum Beispiel um kubectl-Befehle auszuführen. Ihre Workerknoten können mit dem Master über den Private-Cloud-Serviceendpunkt kommunizieren. Weitere Informationen zu den Befehlsoptionen finden Sie in den Referenzdokumenten zur CLI cluster create vpc-gen2.
```
ibmcloud ks cluster create vpc-gen2 --name myvpc-cluster --zone us-south-1 --version 1.35 --flavor bx2.2x8 --workers 1 --vpc-id VPC_ID --subnet-id VPC_SUBNET_ID
```

Prüfen Sie den Status Ihres Clusters. Die Bereitstellung des Clusters kann einige Minuten dauern.

Überprüfen Sie, ob der Status (State) des Clusters normal ist.

    ibmcloud ks cluster ls --provider vpc-gen2
    ```
2. Laden Sie die Kubernetes-Konfigurationsdateien herunter.
```sh {: pre}
    ibmcloud ks cluster config --cluster myvpc-cluster
    ```
3. Stellen Sie sicher, dass die `kubectl`-Befehle mit Ihrem Cluster ordnungsgemäß ausgeführt werden. Überprüfen Sie dazu die Serverversion der Kubernetes-CLI wie folgt.
```sh {: pre}
    kubectl version  --short
    ```
    Beispielausgabe
    ```sh {: screen}
    Client Version: 1.35
    Server Version: 1.35+IKS
    ```

Privat verfügbare App bereitstellen

Erstellen Sie eine Kubernetes-Bereitstellung, um eine einzelne App-Instanz als Pod auf Ihrem Workerknoten in Ihrem VPC-Cluster bereitzustellen.

Kopieren Sie den Quellcode der Hello World-App in Ihr Benutzer-Home-Verzeichnis. Das Repository enthält verschiedene Versionen einer ähnlichen App in Ordnern, deren Namen jeweils mit Lab beginnen. Jede Version enthält die folgenden Dateien:
- Dockerfile: Die Builddefinitionen für das Image.
- app.js: Die App 'Hello World'.
- package.json: Metadaten zur App.
```
git clone https://github.com/IBM/container-service-getting-started-wt.git
```

Rufen Sie das Lab 1-Verzeichnis auf.

cd 'container-service-getting-started-wt/Lab 1'

Verwenden Sie einen vorhandenen Registry-Namensbereich oder erstellen Sie einen solchen, wie beispielsweise vpc-gen2.
```
ibmcloud cr namespace-list
```
```
ibmcloud cr namespace-add vpc-gen2
```
Erstellen Sie ein Docker-Image, das die Dateien für die App aus dem Verzeichnis Lab 1 enthält.

Verwenden Sie im Imagenamen nur alphanumerische Zeichen in Kleinschreibung oder Unterstreichungszeichen (_). Vergessen Sie nicht den Punkt (.) am Ende des Befehls. Der Punkt signalisiert Docker, im aktuellen Verzeichnis nach der Dockerfile zu suchen und Artefakte zum Erstellen des Image zu erstellen.
```
docker build -t us.icr.io/<namespace>/hello-world:1 .
```
Überprüfen Sie nach der Beendigung des Buildprozesses, dass die folgende Nachricht über die erfolgreiche Ausführung angezeigt wird:
```
=> exporting to image                                                                           0.0s
=> => exporting layers                                                                          0.0s
=> => writing image sha256:3ca1eb1d0998f738b552d4c435329edf731fe59e427555b78ba2fb54f2017906     0.0s
=> => naming to <region>.icr.io/<namespace>/hello-world:1                                       0.0s
```
Melden Sie sich bei IBM Cloud Container Registry an.
```
ibmcloud cr login
```
Übertragen Sie das Image mit einer Push-Operation in den von Ihnen erstellten Namensbereich IBM Cloud Container Registry. Falls Sie die App zu einem späteren Zeitpunkt ändern müssen, wiederholen Sie diese Schritte, um eine weitere Version des Image zu erstellen. Hinweis: Erfahren Sie mehr über das Sichern der persönlichen Daten bei der Arbeit mit Container-Images.
```
docker push us.icr.io/<namespace>/hello-world:1
```
Erstellen Sie eine Bereitstellung für Ihre App. Bereitstellungen werden zum Verwalten von Pods verwendet, die containerisierte Instanzen einer App enthalten. Der folgende Befehl stellt die App in einem einzelnen Pod bereit. Im vorliegenden Lernprogramm wird der Bereitstellung der Name hello-world-deployment zugeordnet. Sie können jedoch einen eigenen Namen verwenden.
```
kubectl create deployment hello-world-deployment --image=us.icr.io/vpc-gen2/hello-world:1
```
Beispielausgabe
```
deployment.apps/hello-world-deployment created
```
Erfahren Sie mehr über das Sichern der persönlichen Daten bei der Arbeit mit Kubernetes-Ressourcen.

Machen Sie die App zugänglich, indem Sie die Bereitstellung als Service vom Typ 'NodePort' zur Verfügung stellen. Da Ihre VPC-Workerknoten nur mit einem privaten Teilnetz verbunden sind, wird dem Service 'NodePort' nur eine private IP-Adresse zugeordnet und der Service wird nicht im öffentlichen Netz zugänglich gemacht. Andere Services, die im privaten Netz ausgeführt werden, können auf Ihre App über die private IP-Adresse des Service 'NodePort' zugreifen.

kubectl expose deployment/hello-world-deployment --type=NodePort --name=hello-world-service --port=8080 --target-port=8080

Beispielausgabe

service/hello-world-service exposed

Informationen über die Befehlsoptionen.
Parameter	Beschreibung
`expose`	Macht eine Kubernetes-Ressource, wie zum Beispiel eine Bereitstellung, als Kubernetes Service zugänglich, sodass Benutzer anhand der IP-Adresse des Service auf die Ressource zugreifen können.
`deployment/<hello-world-deployment>`	Der Ressourcentyp und der Name der Ressource, die mit diesem Service verfügbar gemacht werden soll.
`--name=<hello-world-service>`	Der Name des Service.
`--type=NodePort`	Der Typ des Service, der erstellt werden soll. In dieser Lerneinheit erstellen Sie einen Service vom Typ `NodePort`. In der folgenden Lerneinheit erstellen Sie einen Service vom Typ `LoadBalancer`.
`--port=<8080>`	Der Port, über den der Service für externen Netzverkehr empfangsbereit ist.
`--target-port=<8080>`	Der Port, über den Ihre App empfangsbereit ist und an den der Service eingehenden Netzverkehr leitet. In diesem Beispiel stimmt der Zielport (`target-port`) mit dem Port (`port`) überein, jedoch können andere Apps, die Sie erstellen, auch einen anderen Port verwenden.

Jetzt, da alle Bereitstellungsarbeiten erledigt sind, können Sie Ihre App innerhalb Ihres Clusters testen. Rufen Sie die Details zur Bildung der privaten IP-Adresse ab, mit der Sie auf Ihre App zugreifen können.

Rufen Sie Informationen zum Service ab, um zu ermitteln, welcher Knotenport (NodePort) zugewiesen wurde. Knotenportnummern (NodePort) werden nach dem Zufallsprinzip zugewiesen, wenn sie mit dem Befehl expose generiert werden, bewegen sich aber im Bereich 30000-32767. In diesem Beispiel hat NodePort den Wert 30872.

    kubectl describe service hello-world-service
    ```
    Beispielausgabe

    ```sh {: screen}
    NAME:                   hello-world-service
    Namespace:              default
    Labels:                 run=hello-world-deployment
    Selector:               run=hello-world-deployment
    Type:                   NodePort
    IP:                     10.xxx.xx.xxx
    Port:                   <unset> 8080/TCP
    NodePort:               <unset> 30872/TCP
    Endpoints:              172.30.xxx.xxx:8080
    Session Affinity:       None
    No events.
    ```
2. Listen Sie die Pods auf, die Ihre App ausführen, und notieren Sie den Podnamen.
```sh {: pre}
    kubectl get pods
    ```
    Beispielausgabe
    ```sh {: screen}
    NAME                                     READY     STATUS        RESTARTS   AGE
    hello-world-deployment-d99cddb45-lmj2v   1/1       Running       0          2d
    ```
3. Rufen Sie eine Beschreibung Ihres Pods ab, um zu ermitteln, auf welchem Workerknoten der Pod ausgeführt wird. In der Beispielausgabe wird der Pod auf dem Workerknoten **10.xxx.xx.xxx** ausgeführt.
```sh {: pre}
    kubectl describe pod hello-world-deployment-d99cddb45-lmj2v
    ```
    Beispielausgabe

    ```sh {: screen}
    NAME:               hello-world-deployment-d99cddb45-lmj2v
    Namespace:          default
    Priority:           0
    PriorityClassName:  <none>
    Node:               10.xxx.xx.xxx/10.xxx.xx.xxx
    Start Time:         Mon, 22 Apr 20122 12:40:48 -0400
    Labels:             pod-template-hash=d99cddb45
                        run=hello-world-deployment
    Annotations:        kubernetes.io/psp=ibm-privileged-psp
    Status:             Running
    IP:                 172.30.xxx.xxx
    ...
    ```

Melden Sie sich bei dem Pod an, sodass Sie eine Anforderung aus dem Cluster an Ihre App senden können.
```
kubectl exec -it hello-world-deployment-d99cddb45-lmj2v /bin/sh
```

Senden Sie eine Anforderung an den NodePort-Service, indem Sie die private IP-Adresse des Workerknotens und den Knotenport verwenden, den Sie zuvor abgerufen haben.

wget -O - 10.xxx.xx.xxx:30872

Beispielausgabe

Connecting to 10.xxx.xx.xxx:30872 (10.xxx.xx.xxx:30872)
Hello world from hello-world-deployment-d99cddb45-lmj2v! Your app is up and running in a cluster!
-                    100% |*****************************************************************************************|    88   0:00:00 ETA

Geben Sie zum Schließen Ihrer Podsitzung den Befehl exit ein.

Lastausgleichsfunktion für die VPC einrichten, um die App öffentlich zugänglich zu machen

Richten Sie eine VPC-Lastausgleichsfunktion ein, um Ihre App im öffentlichen Netz zugänglich zu machen.

Wenn Sie einen Kubernetes Service vom Typ LoadBalancer (Lastausgleichsfunktion) in Ihrem Cluster erstellen, wird eine Lastausgleichsfunktion für VPC automatisch in Ihrer VPC außerhalb Ihres Clusters erstellt. Die Lastausgleichsfunktion arbeitet mit mehreren Zonen und leitet Anforderungen für Ihre App über die privaten Knotenports (NodePorts) weiter, die automatisch auf Ihren Workerknoten geöffnet werden. Das folgende Diagramm zeigt, wie ein Benutzer über die Lastausgleichsfunktion auf die Services einer App zugreift, auch wenn der Workerknoten nur mit einem privaten Teilnetz verbunden ist.

VPC-Lastenausgleich für einen Cluster. — VPC-Lastenausgleich für einen Cluster

Erstellen Sie einen Kubernetes Service vom Typ LoadBalancer in Ihrem Cluster, um die App 'hello world' öffentlich zugänglich zu machen.

kubectl expose deployment/hello-world-deployment --type=LoadBalancer --name=hw-lb-svc  --port=8080 --target-port=8080

Beispielausgabe

service "hw-lb-svc" exposed

Informationen über die Befehlsoptionen.
Parameter	Beschreibung
`expose`	Macht eine Kubernetes-Ressource, wie zum Beispiel eine Bereitstellung, als Kubernetes Service zugänglich, sodass Benutzer anhand der IP-Adresse des Service auf die Ressource zugreifen können.
`deployment/<hello-world-deployment>`	Der Ressourcentyp und der Name der Ressource, die mit diesem Service verfügbar gemacht werden soll.
`--name=<hello-world-service>`	Der Name des Service.
`--type=LoadBalancer`	Der Typ des Kubernetes Service, der erstellt werden soll. In dieser Lerneinheit erstellen Sie einen Service vom Typ `LoadBalancer`.
`--port=<8080>`	Der Port, über den der Service für externen Netzverkehr empfangsbereit ist.
`--target-port=<8080>`	Der Port, über den Ihre App empfangsbereit ist und an den der Service eingehenden Netzverkehr leitet. In diesem Beispiel stimmt der Zielport (`target-port`) mit dem Port (`port`) überein, jedoch können andere Apps, die Sie erstellen, auch einen anderen Port verwenden.

Überprüfen Sie, ob der Kubernetes Service vom Typ LoadBalancer in Ihrem Cluster erfolgreich erstellt wurde. Wenn Sie den Kubernetes Service LoadBalancer erstellen, wird automatisch eine VPC-Lastausgleichsfunktion für Sie erstellt. Die VPC-Lastausgleichsfunktion weist Ihrem Kubernetes Service 'LoadBalancer' einen Hostnamen zu, der in der Ausgabe Ihrer CLI im Feld LoadBalancer Ingress angezeigt wird. Die Bereitstellung der VPC-Lastausgleichsfunktion in Ihrer VPC dauert einige Minuten. Solange der VPC-Load-Balancer noch nicht bereit ist, können Sie nicht über dessen Hostnamen auf den Dienst LoadBalancer Kubernetes zugreifen.

kubectl describe service hw-lb-svc

Beispiel-CLI-Ausgabe

NAME:                     hw-lb-svc
Namespace:                default
Labels:                   app=hello-world-deployment
Annotations:              <none>
Selector:                 app=hello-world-deployment
Type:                     LoadBalancer
IP:                       172.21.xxx.xxx
LoadBalancer Ingress:     1234abcd-us-south.lb.appdomain.cloud
Port:                     <unset> 8080/TCP
TargetPort:               8080/TCP
NodePort:                 <unset> 32040/TCP
Endpoints:
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
    Type    Reason                Age   From                Message
    ----    ------                ----  ----                -------
    Normal  EnsuringLoadBalancer  1m    service-controller  Ensuring load balancer
    Normal  EnsuredLoadBalancer   1m    service-controller  Ensured load balancer

Überprüfen Sie, ob die VPC-Lastausgleichsfunktion in Ihrer VPC erfolgreich erstellt wurde. Überprüfen Sie, ob in der Ausgabe die VPC-Lastausgleichsfunktion den Bereitstellungsstatus active und den Betriebsstatus online aufweist.

Der Name der VPC-Lastausgleichsfunktion hat das Format kube-<cluster_ID>-<kubernetes_lb_service_UID>. Führen Sie ibmcloud ks cluster get --cluster CLUSTER_NAME aus, um Ihre Cluster-ID anzuzeigen. Zum Ermitteln der UID des Kubernetes Service vom Typ LoadBalancer führen Sie den Befehl kubectl get svc hw-lb-svc -o yaml aus und suchen in der Ausgabe nach dem Feld metadata.uid.
```
ibmcloud is load-balancers
```
In der folgenden Beispielausgabe der Befehlszeilenschnittstelle wird die erstellte VPC-Lastausgleichsfunktion namens kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306 für den Kubernetes Service vom Typ LoadBalancer angezeigt:
```
ID                                          Name                                                         Family        Subnets               Is public   Provision status   Operating status   Resource group
r006-d044af9b-92bf-4047-8f77-a7b86efcb923   kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306   Application   mysubnet-us-south-3   true        active             online             default
```
Senden Sie eine Anforderung an Ihre App, indem Sie den Hostnamen und den Port des Kubernetes-Service vom Typ LoadBalancer (siehe Schritt 2), der jeweils von der VPC-Lastausgleichsfunktion zugewiesen wurde, mit Curl aufrufen.
```
curl 1234abcd-us-south.lb.appdomain.cloud:8080
```
Beispielausgabe
```
Hello world from hello-world-deployment-5fd7787c79-sl9hn! Your app is up and running in a cluster!
```

Weitere Schritte

Jetzt, da Sie über einen VPC-Cluster verfügen, können Sie sich eingehender über die verfügbaren Möglichkeiten informieren.

Benötigen Sie Hilfe, haben Sie fragen oder wollen Sie ein Feedback zu VPC-Clustern zurückgeben? Versuchen Sie, im Slack-Kanalzu posten.