Configuration de votre premier cluster dans votre cloud privé virtuel (VPC)

Créez un cluster IBM Cloud® Kubernetes Service dans votre cloud privé virtuel (VPC).

Grâce aux clusters d' IBM Cloud Kubernetes Service s sur VPC, vous pouvez créer votre cluster sur la nouvelle génération de la plateforme IBM Cloud, au sein de votre cloud privé virtuel. Un VPC vous offre la sécurité d'un environnement de cloud privé avec l'évolutivité dynamique d'un cloud public. VPC utilise la prochaine version des fournisseurs d’infrastructure IBM Cloud Kubernetes Service, avec un ensemble restreint de fonctionnalités de l’API, de l’interface de ligne de commande (CLI) et de la console d’ v2. Vous pouvez créer uniquement des clusters standard pour VPC.

Public ciblé

Ce tutoriel s'adresse aux administrateurs qui créent un cluster dans IBM Cloud Kubernetes Service dans le VPC pour la première fois.

Objectifs

Au cours des leçons de ce tutoriel, vous allez créer un cluster IBM Cloud Kubernetes Service dans un cloud privé virtuel (VPC). Ensuite, vous allez déployer une application et l'exposer au public à l'aide d'un équilibreur de charge.

Ce que vous obtiendrez

Dans ce tutoriel, vous allez créer les ressources suivantes. Des étapes facultatives permettent de supprimer ces ressources si vous ne souhaitez pas les conserver après avoir suivi le tutoriel.

  • Un cluster VPC
  • Une application Hello World simple déployée sur votre cluster
  • Un équilibreur de charge VPC pour exposer votre application

Prérequis

Pour configurer les droits et l'environnement de ligne de commande, suivez la procédure prérequise ci-après.

Droits
Si vous êtes le titulaire du compte, vous disposez déjà des autorisations nécessaires pour créer un cluster et pouvez passer à l'étape suivante. Sinon, demandez au propriétaire du compte de configurer la clé d'API et de vous octroyer les droits utilisateur minimaux dans IBM Cloud IAM.
Outils de ligne de commande
Pour accéder rapidement à vos ressources à partir de la ligne de commande, essayez IBM Cloud Shell. Sinon, configurez votre environnement de ligne de commande local en procédant comme suit :
  1. Installez l'interface de ligne de commande IBM Cloud(ibmcloud), le plug-in Kubernetes Service (ibmcloud ks) et le plug-in IBM Cloud Container Registry (ibmcloud cr).
  2. Installez les interfaces CLI Red Hat OpenShift (oc) et Kubernetes (kubectl).
  3. Pour utiliser VPC, installez le plug-in infrastructure-service. Le préfixe pour l'exécution des commandes est ibmcloud is.
    ibmcloud plugin install infrastructure-service
  4. Mettez à niveau le plug-in Kubernetes Service vers la version la plus récente.
    ibmcloud plugin update kubernetes-service
  5. Assurez-vous que la version de kubectl correspond à la version Kubernetes de votre cluster VPC. Ce tutoriel permet de créer un cluster exécutant la version 1.35.

Création d'un cluster dans un environnement VPC

Créez un cluster IBM Cloud Kubernetes Service dans votre environnement VPC IBM Cloud. Pour plus d'informations sur VPC, voir Initiation au cloud privé virtuel.

  1. Connectez-vous au compte, au groupe de ressources et à la région IBM Cloud où vous souhaitez créer votre environnement VPC. Le VPC doit être configuré dans la même région métropolitaine multizone que celle où vous souhaitez créer votre cluster. Dans le cadre de ce tutoriel, vous allez créer un VPC dans la région us-south. Pour connaître les autres régions prises en charge, voir Métropoles multizone pour des clusters VPC. Si vous disposez d'un identifiant fédéré, incluez l'option --sso.
    ibmcloud login -r us-south [-g <resource_group>] [--sso]
  2. Créez un VPC pour votre cluster. Pour plus d'informations, consultez la documentation relative à la création d'un VPC dans la console ou l'interface CLI.
    1. Créez un VPC appelé myvpc et notez l'ID dans la sortie. Les VPC fournissent un environnement isolé pour que vos charges de travail s'exécutent dans le cloud public. Vous pouvez utiliser le même VPC pour plusieurs clusters, par conséquent, si vous prévoyez de disposer de différents clusters, hébergez des microservices distincts ayant besoin de communiquer entre eux. Si vous souhaitez séparer vos clusters, par exemple, pour différents services, vous pouvez créer un VPC pour chaque cluster.
        ibmcloud is vpc-create myvpc
    ```
2. Créez un sous-réseau pour votre VPC et notez son **ID**. Prenez en compte les informations suivantes lorsque vous créez le sous-réseau VPC :
    - **Zones** : vous devez disposer d'un sous-réseau VPC pour chaque zone incluse dans votre cluster. Les zones disponibles dépendent de la région métropolitaine dans laquelle vous avez créé le VPC. Pour répertorier les zones disponibles dans la région, exécutez la commande `ibmcloud is zones`.
    - **Adresses IP** : les sous-réseaux VPC fournissent des adresses IP privées pour vos noeuds worker et des services d'équilibreur de charge dans votre cluster, par conséquent, [créez un sous-réseau avec suffisamment d'adresses IP](/docs/containers?topic=containers-vpc-subnets#vpc_basics_subnets), par exemple, 256. Vous ne pouvez pas modifier le nombre d'adresses IP qu'un sous-réseau VPC a plus tard.
    - **Passerelles publiques** : vous n'avez pas besoin de connecter une passerelle publique pour exécuter ce tutoriel. A la place, vous pouvez maintenir vos noeuds worker isolés de l'accès public en utilisant des équilibreurs de charge VPC pour exposer les charges de travail de manière sécurisée. Vous pouvez connecter une passerelle publique si vos noeuds worker ont besoin d'accéder à une URL publique.

```sh {: pre}
    ibmcloud is subnet-create mysubnet1 VPC_ID --zone us-south-1 --ipv4-address-count 256
    ```
  3. Créez un cluster dans votre VPC dans la même zone que le sous-réseau. Par défaut, votre cluster est créé avec un noeud final de service cloud public et un noeud final de service cloud privé. Vous pouvez utiliser le noeud final de service cloud public pour accéder au maître Kubernetes, par exemple pour exécuter des commandes kubectl, à partir de votre machine locale. Vos noeuds worker peuvent communiquer avec le maître sur le noeud final de service de cloud privé. Pour plus d'informations sur les options de commandes, voir la documentation de référence 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
  4. Vérifiez l'état de votre cluster. La mise à disposition du cluster peut prendre quelques minutes.
    1. Vérifiez que la valeur de la zone State du cluster est normal.
        ibmcloud ks cluster ls --provider vpc-gen2
    ```
2. Téléchargez les fichiers de configuration Kubernetes.
```sh {: pre}
    ibmcloud ks cluster config --cluster myvpc-cluster
    ```
3. Vérifiez que les commandes `kubectl` fonctionnent correctement avec votre cluster en identifiant la version du serveur CLI de Kubernetes.
```sh {: pre}
    kubectl version  --short
    ```
    Exemple de sortie
    ```sh {: screen}
    Client Version: 1.35
    Server Version: 1.35+IKS
    ```

Déploiement d'une application disponible en privé

Créez un déploiement Kubernetes afin de déployer une instance d'application unique en tant que pod sur votre noeud worker dans votre cluster VPC.

  1. Clonez le code source de l'application Hello world dans votre répertoire personnel. Ce répertoire héberge différentes versions d'une application similaire dans des dossiers débutant chacun par Lab. Chaque version contient les fichiers suivants :

    • Dockerfile : définitions pour génération de l'image.
    • app.js : application Hello World.
    • package.json : métadonnées de l'application.
    git clone https://github.com/IBM/container-service-getting-started-wt.git

  2. Accédez au répertoire Lab 1.

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

  3. Utilisez un espace de noms de registre existant ou créez-en un, par exemple, vpc-gen2.

    ibmcloud cr namespace-list

    ibmcloud cr namespace-add vpc-gen2

  4. Générez une image Docker qui inclut les fichiers d'application du répertoire Lab 1.

    Utilisez uniquement des caractères alphanumériques en minuscules ou des traits de soulignement (_) dans le nom de l'image. N'oubliez pas le point (.) à la fin de la commande. Ce point indique à Docker de rechercher le Dockerfile et les artefacts de génération de l'image dans le répertoire actuel.

    docker build -t us.icr.io/<namespace>/hello-world:1 .

    Lorsque la génération est terminée, vérifiez que le message de réussite suivant est bien affiché :

    => 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

  5. Connectez-vous à IBM Cloud Container Registry.

    ibmcloud cr login

  6. Envoyez l'image par commande push à l'espace de nom IBM Cloud Container Registry que vous avez créé. Si vous avez besoin de modifier l'application plus tard, répétez ces étapes pour créer une autre version de l'image. Remarque : découvrez comment sécuriser vos informations personnelles lorsque vous utilisez des images de conteneur.

    docker push us.icr.io/<namespace>/hello-world:1

  7. Créez un déploiement pour votre application. Les déploiements sont utilisés pour gérer les pods, lesquels contiennent des instances conteneurisées d'une application. La commande suivante déploie l'application dans un pod unique. Dans le cadre de ce tutoriel, le déploiement est intitulé hello-world-deployment, mais vous pouvez lui donner un nom de votre choix.

    kubectl create deployment hello-world-deployment --image=us.icr.io/vpc-gen2/hello-world:1

    Exemple de sortie

    deployment.apps/hello-world-deployment created

    Découvrez comment sécuriser vos informations personnelles lorsque vous utilisez des ressources Kubernetes.

  8. Rendez l'application accessible en exposant le déploiement en tant que service NodePort. Etant donné que vos noeuds worker VPC sont connectés à un sous-réseau privé uniquement, une seule adresse IP est affectée au service NodePort et celui-ci n'est pas exposé sur le réseau public. Les autres services qui s'exécutent sur le réseau privé peuvent accéder à votre application à l'aide de l'adresse IP privée du service NodePort.

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

    Exemple de sortie

    service/hello-world-service exposed
    Informations sur les options de la commande.
    Paramètre Description
    expose Exposez une ressource Kubernetes, telle qu'un déploiement, en tant que service Kubernetes de manière à permettre aux utilisateurs d'accéder à cette ressource à l'aide de l'adresse IP du service.
    deployment/*<hello-world-deployment>* Type et nom de la ressource à exposer avec ce service.
    --name=*<hello-world-service>* Nom du service.
    --type=NodePort Type de service à créer. Dans cette leçon, vous créez un service NodePort. Dans la leçon suivante, vous créez un service LoadBalancer.
    --port=*<8080>* Port sur lequel le service est à l'écoute du trafic réseau externe.
    --target-port=*<8080>* Port sur lequel votre application est à l'écoute et vers lequel le service dirige le trafic réseau entrant. Dans cet exemple, target-port et port sont identiques, mais les autres applications que vous créez peuvent utiliser un autre port.

  9. Maintenant que la tâche de déploiement est terminée, vous pouvez tester votre application à partir du cluster. Procurez-vous les détails qui constituent l'adresse IP privée que vous pourrez utiliser pour accéder à votre application.

    1. Extrayez les informations sur le service pour déterminer le port de noeud (NodePort) qui a été affecté. Les ports de noeud (NodePorts) sont affectés aléatoirement lorsqu'ils sont générés par la commande expose, mais ils sont compris entre 30000 et 32767. Dans cet exemple, la valeur de NodePort est 30872.
        kubectl describe service hello-world-service
    ```
    Exemple de sortie

    ```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. Répertoriez les pods qui exécutent votre application et notez les noms de pod.
```sh {: pre}
    kubectl get pods
    ```
    Exemple de sortie
    ```sh {: screen}
    NAME                                     READY     STATUS        RESTARTS   AGE
    hello-world-deployment-d99cddb45-lmj2v   1/1       Running       0          2d
    ```
3. Décrivez votre pod afin de déterminer le noeud worker sur lequel il s'exécute. Dans l'exemple de sortie, le noeud worker sur lequel s'exécute le pod est **10.xxx.xx.xxx**.
```sh {: pre}
    kubectl describe pod hello-world-deployment-d99cddb45-lmj2v
    ```
    Exemple de sortie

    ```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
    ...
    ```

  10. Connectez-vous au pod afin de pouvoir effectuer une demande à votre application au sein du cluster.

    kubectl exec -it hello-world-deployment-d99cddb45-lmj2v /bin/sh

  11. Effectuez une demande au service NodePort en utilisant l'adresse IP privée et le port de noeud du noeud worker que vous avez extraits précédemment.

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

    Exemple de sortie

    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

    Pour fermer votre session de pod, entrez exit.

Configuration d'un équilibreur de charge pour VPC afin d'exposer votre application au public

Configurez un équilibreur de charge VPC pour exposer votre application sur le réseau public.

Lorsque vous créez un service Kubernetes LoadBalancer dans votre cluster, un équilibreur de charge VPC est automatiquement créé dans votre VPC, en dehors de votre cluster. L'équilibreur de charge comprend plusieurs zones et achemine des demandes pour votre application via les ports de noeud privés qui sont automatiquement ouverts sur vos noeuds worker. Le diagramme ci-après illustre la façon dont un utilisateur accède au service d'une application via l'équilibreur de charge, même si votre noeud worker n'est connecté qu'à un sous-réseau privé.

Équilibrage de charge VPC pour un cluster.
Équilibrage de charge VPC pour un cluster

  1. Créez un service Kubernetes LoadBalancer dans votre cluster afin d'exposer l'application Hello world au public.

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

    Exemple de sortie

    service "hw-lb-svc" exposed
    Informations sur les options de la commande.
    Paramètre Description
    expose Exposez une ressource Kubernetes, telle qu'un déploiement, en tant que service Kubernetes de manière à permettre aux utilisateurs d'accéder à cette ressource à l'aide de l'adresse IP du service.
    deployment/*<hello-world-deployment>* Type et nom de la ressource à exposer avec ce service.
    --name=*<hello-world-service>* Nom du service.
    --type=LoadBalancer Type de service Kubernetes à créer. Dans cette leçon, vous créez un service LoadBalancer.
    --port=*<8080>* Port sur lequel le service est à l'écoute du trafic réseau externe.
    --target-port=*<8080>* Port sur lequel votre application est à l'écoute et vers lequel le service dirige le trafic réseau entrant. Dans cet exemple, target-port et port sont identiques, mais les autres applications que vous créez peuvent utiliser un autre port.

  2. Vérifiez que le service Kubernetes LoadBalancer a bien été créé dans votre cluster. Lorsque vous créez un service Kubernetes LoadBalancer dans votre cluster, un équilibreur de charge VPC est automatiquement créé pour vous. L'équilibreur de charge VPC affecte un nom d'hôte à votre service Kubernetes LoadBalancer visible dans la zone LoadBalancer Ingress de votre sortie d'interface CLI. La mise à disposition dans votre VPC de l'équilibreur de charge VPC dure quelques minutes. Tant que l'équilibreur de charge VPC n'est pas prêt, vous ne pouvez pas accéder au service LoadBalancer Kubernetes via son nom d'hôte.

    kubectl describe service hw-lb-svc

    Exemple de sortie de l'interface CLI

    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

  3. Vérifiez que l'équilibreur de charge VPC a bien été créé dans votre VPC. Dans la sortie, assurez-vous que la zone Provision Status contient la valeur active et que la zone Operating Status contient la valeur online pour l'équilibreur de charge VPC.

    L'équilibreur de charge de VPC est nommé au format kube-<cluster_ID>-<kubernetes_lb_service_UID>. Pour afficher votre ID de cluster, exécutez ibmcloud ks cluster get --cluster CLUSTER_NAME. Pour voir l'ID utilisateur du service Kubernetes LoadBalancer, exécutez la commande kubectl get svc hw-lb-svc -o yaml et recherchez la zone metadata.uid dans la sortie.

    ibmcloud is load-balancers

    Dans l'exemple de sortie d'interface de ligne de commande suivant, l'équilibreur de charge VPC nommé kube-bsaucubd07dhl66e4tgg-1f4f408ce6d2485499bcbdec0fa2d306 est créé pour le service Kubernetes LoadBalancer:

    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

  4. Envoyez une demande à votre application en exécutant une commande curl sur le nom d'hôte et le port du service Kubernetes LoadBalancer qui est affecté par l'équilibreur de charge VPC identifié à l'étape 2.

    curl 1234abcd-us-south.lb.appdomain.cloud:8080

    Exemple de sortie

    Hello world from hello-world-deployment-5fd7787c79-sl9hn! Your app is up and running in a cluster!

Étape suivante ?

Maintenant que vous disposez d'un cluster de VPC, découvrez ce que vous pouvez faire.

Vous avez besoin d'aide, vous avez des questions ou souhaitez nous faire part de vos commentaires sur les clusters de VPC ? Essayez de publier dans le canal Slack.