GSP005

Présentation

L'objectif de cet atelier pratique est de transformer du code que vous avez développé en application dupliquée exécutée sur Kubernetes, lui-même exécuté sur Kubernetes Engine. Pour cet atelier, le code sera une simple application node.js Hello World.

Voici un schéma des différents éléments impliqués dans cet atelier afin de vous aider à comprendre comment ils interagissent. Utilisez ce schéma comme référence au fur et à mesure de votre progression. Il devrait prendre tout son sens lorsque vous aurez terminé l'atelier. (Vous pouvez choisir de l'ignorer pour le moment.)

Kubernetes est un projet Open Source (disponible sur kubernetes.io) qui peut être exécuté sur de nombreux environnements différents : ordinateurs portables, clusters multinœuds haute disponibilité, clouds publics, déploiements sur site, machines virtuelles, serveurs physiques, etc.

Dans cet atelier, l'utilisation d'un environnement géré comme Kubernetes Engine (une version de Kubernetes hébergée par Google et exécutée sur Compute Engine) vous permettra de bien vous familiariser avec Kubernetes plutôt que de passer du temps à configurer l'infrastructure sous-jacente.

Objectifs de l'atelier

• Créer un serveur Node.js

• Créer une image de conteneur Docker

• Créer un cluster de conteneur

• Créer un pod Kubernetes

• Assurer le scaling de vos services

Prérequis

• Une bonne connaissance des éditeurs de texte Linux standards tels que vim, emacs ou nano vous sera utile.

Nous vous invitons à éviter le copier-coller et à saisir directement les commandes, afin de mieux assimiler les concepts fondamentaux. De nombreux ateliers comportent cependant un bloc de code qui réunit les commandes à saisir. Vous pouvez facilement copier et coller les commandes de ce bloc aux emplacements appropriés dans le cadre de l'atelier.

Configuration

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google. L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.

4. Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

5. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas aux essais offerts.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

2. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Créer votre application Node.js

À l'aide de Cloud Shell, créez un serveur Node.js simple que vous allez déployer sur Kubernetes Engine :

vi server.js

Lancez l'éditeur :

i

Ajoutez le contenu suivant au fichier :

var http = require('http');
var handleRequest = function(request, response) {
  response.writeHead(200);
  response.end("Hello World!");
}
var www = http.createServer(handleRequest);
www.listen(8080);

Enregistrez le fichier server.js : Échap, puis saisissez :

:wq

L'exécutable node étant installé sur Cloud Shell, exécutez la commande suivante (qui ne produit pas de résultat) pour démarrer le serveur nœud :

node server.js

Utilisez la fonctionnalité d'aperçu Web intégrée à Cloud Shell pour ouvrir un nouvel onglet dans le navigateur et transmettre une demande à l'instance que vous venez de démarrer sur le port 8080.

Un nouvel onglet de navigateur contenant les résultats s'ouvre :

Avant de continuer, retournez dans Cloud Shell et saisissez Ctrl+c pour arrêter le serveur nœud en cours d'exécution.

À présent, vous allez empaqueter cette application dans un conteneur Docker.

Créer une image de conteneur Docker

Créez maintenant un Dockerfile qui décrit l'image que vous voulez créer. Les images de conteneurs Docker peuvent être basées sur des images existantes. Pour cette image, nous partirons donc d'une image de nœud existante.

vi Dockerfile

Lancez l'éditeur.

i

Ajoutez le contenu suivant :

FROM node:6.9.2
EXPOSE 8080
COPY server.js .
CMD node server.js

Cette "recette" pour l'image Docker :

• se basera sur l'image node trouvée sur Docker Hub.
• exposera le port 8080
• copiera notre fichier server.js sur l'image.
• démarrera le serveur nœud comme nous l'avons déjà fait manuellement.

Enregistrez ce fichier Dockerfile en appuyant sur Échap, puis saisissez :

:wq

Créez l'image à l'aide de la commande ci-dessous, en remplaçant PROJECT_ID par l'ID de votre projet GCP que vous trouverez dans la console et à la section Connection Details de l'atelier :

docker build -t gcr.io/PROJECT_ID/hello-node:v1 .

Le téléchargement et l'extraction de tous les éléments peuvent prendre un peu de temps, mais des barres de progression s'affichent pendant la création de l'image.

Une fois celle-ci terminée, testez l'image en local avec la commande suivante, qui exécutera un conteneur Docker comme daemon sur le port 8080 à partir de l'image de conteneur que vous venez de créer. (Remplacez PROJECT_ID par l'ID de votre projet GCP que vous trouverez dans la console et à la section Connection Details de l'atelier.)

docker run -d -p 8080:8080 gcr.io/PROJECT_ID/hello-node:v1

Votre résultat doit se présenter comme suit :

325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998

Pour afficher les résultats, utilisez la fonction d'aperçu Web de Cloud Shell :

Vous pouvez également utiliser curl à partir de votre invite Cloud Shell :

curl http://localhost:8080

Voici le résultat que vous devez obtenir :

Hello World!

Ensuite, arrêtez le conteneur en cours d'exécution.

Recherchez l'ID du conteneur Docker en exécutant cette commande :

docker ps

Votre résultat doit se présenter comme suit :

CONTAINER ID        IMAGE                              COMMAND
2c66d0efcbd4        gcr.io/PROJECT_ID/hello-node:v1    "/bin/sh -c 'node

Arrêtez le conteneur avec la commande suivante, en remplaçant l'ID du conteneur (CONTAINER ID) obtenu à l'étape précédente :

docker stop [CONTAINER ID]

Le résultat de votre console doit se présenter comme suit (l'ID de votre conteneur) :

2c66d0efcbd4

Maintenant que l'image fonctionne comme prévu, transférez-la vers Google Container Registry, un dépôt privé pour vos images Docker accessible à partir de vos projets Google Cloud.

Exécutez la commande suivante en remplaçant PROJECT_ID par l'ID de votre projet GCP que vous trouverez dans la console ou à la section Connection Details de l'atelier.

gcloud auth configure-docker

docker push gcr.io/PROJECT_ID/hello-node:v1

Le transfert initial peut prendre quelques minutes. Des barres de progression s'affichent pendant la création.

The push refers to a repository [gcr.io/qwiklabs-gcp-6h281a111f098/hello-node]
ba6ca48af64e: Pushed
381c97ba7dc3: Pushed
604c78617f34: Pushed
fa18e5ffd316: Pushed
0a5e2b2ddeaa: Pushed
53c779688d06: Pushed
60a0858edcd5: Pushed
b6ca02dfe5e6: Pushed
v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002

L'image de conteneur est répertoriée dans votre console. Cliquez sur le menu de navigation > Container Registry.

Vous disposez maintenant d'une image Docker disponible au niveau du projet, que Kubernetes peut consulter et orchestrer.

Créer votre cluster

Vous êtes désormais prêt à créer votre cluster Container Engine. Un cluster se compose d'un serveur d'API maître Kubernetes hébergé par Google et d'un ensemble de nœuds de calcul. Les nœuds de calcul correspondent à des machines virtuelles Compute Engine.

Assurez-vous d'avoir défini votre projet à l'aide de gcloud (remplacez PROJECT_ID par l'ID de votre projet GCP, que vous trouverez dans la console et à la section Connection Details de l'atelier) :

gcloud config set project PROJECT_ID

Créez un cluster avec deux nœuds n1-standard-1 (cette opération prend quelques minutes) :

gcloud container clusters create hello-world \
                --num-nodes 2 \
                --machine-type n1-standard-1 \
                --zone us-central1-a

Vous pouvez ignorer en toute sécurité les avertissements qui se présentent lors de la création du cluster.

Le résultat de la console doit se présenter comme suit :

Creating cluster hello-world...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/us-central1-a/clusters/hello-world].
kubeconfig entry generated for hello-world.
NAME         ZONE           MASTER_VERSION  MASTER_IP       MACHINE_TYPE   STATUS
hello-world  us-central1-a  1.5.7           146.148.46.124  n1-standard-1  RUNNING

Remarque : Vous pouvez également créer ce cluster via la console, comme dans l'image ci-dessus : Kubernetes Engine > Kubernetes clusters > Create cluster.

Cliquez sur le menu de navigation > Kubernetes Engine pour découvrir que vous disposez à présent d'un cluster Kubernetes entièrement fonctionnel, exécuté sur Kubernetes Engine :

Il est temps de déployer votre propre application en conteneur sur le cluster Kubernetes. À partir de maintenant, vous utiliserez la ligne de commande kubectl (déjà configurée dans votre environnement Cloud Shell).

Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.

Créer votre cluster.

Créer votre pod

Un pod Kubernetes est un groupe de conteneurs réunis à des fins d'administration et de mise en réseau. Il peut contenir un ou plusieurs conteneurs. Dans cet exemple, vous allez utiliser un seul conteneur créé avec votre image Node.js stockée dans le registre de conteneurs privé. Il diffusera du contenu sur le port 8080.

Créez un pod avec la commande kubectl run (remplacez PROJECT_ID par l'ID de votre projet GCP, que vous trouverez dans la console et à la section Connection Details de l'atelier) :

kubectl create deployment hello-node \
    --image=gcr.io/PROJECT_ID/hello-node:v1

Voici le résultat que vous devez obtenir :

deployment.apps/hello-node created

Comme vous pouvez le voir, vous avez créé un objet déploiement. L'utilisation des déploiements est recommandée pour créer et faire évoluer des pods. Dans le cas présent, un nouveau déploiement gère un seul pod dupliqué qui exécute l'image hello-node:v1.

Pour afficher le déploiement, exécutez la commande suivante :

kubectl get deployments

Voici le résultat que vous devez obtenir :

NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m36s

Pour afficher le pod créé par le déploiement, exécutez cette commande :

kubectl get pods

Voici le résultat que vous devez obtenir :

NAME                         READY     STATUS    RESTARTS   AGE
hello-node-714049816-ztzrb   1/1       Running   0          6m

Nous vous proposons à présent de passer en revue quelques commandes kubectl intéressantes. Aucune d'entre elles ne modifiera l'état du cluster (la documentation complète est disponible sur cette page) :

kubectl cluster-info

kubectl config view

Pour le dépannage :

kubectl get events

kubectl logs <pod-name>

Vous devez maintenant rendre votre pod accessible depuis l'extérieur.

Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.

Créer votre pod

Autoriser le trafic externe

Par défaut, le pod n'est accessible que par le biais de son adresse IP interne au sein du cluster. Pour rendre le conteneur hello-node accessible en dehors du réseau virtuel Kubernetes, vous devez présenter le pod sous la forme d'un service Kubernetes.

Depuis Cloud Shell, vous pouvez présenter le pod au réseau Internet public avec la commande kubectl expose associée à l'indicateur --type="LoadBalancer". Cet indicateur est obligatoire pour créer une adresse IP accessible depuis l'extérieur :

kubectl expose deployment hello-node --type="LoadBalancer" --port=8080

Voici le résultat que vous devez obtenir :

service/hello-node exposed

L'indicateur utilisé dans cette commande spécifie que vous allez utiliser l'équilibreur de charge fourni par l'infrastructure sous-jacente (dans ce cas, l'équilibreur de charge Compute Engine). Remarquez que vous présentez le déploiement, et non le pod directement. Par conséquent, le service obtenu va répartir le trafic sur tous les pods gérés par le déploiement (dans le cas présent, un seul pod, mais vous ajouterez des instances dupliquées par la suite).

Le Kubernetes maître crée l'équilibreur de charge et les règles de transfert Compute Engine associées, les pools cibles et les règles de pare-feu afin de rendre le service entièrement accessible en dehors de Google Cloud Platform.

Pour trouver l'adresse IP publiquement accessible du service, demandez à kubectl de répertorier tous les services du cluster :

kubectl get services

Voici le résultat que vous devez obtenir :

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-node   10.3.250.149   104.154.90.147   8080/TCP   1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Deux adresses IP accessibles par le port 8080 sont répertoriées pour votre service hello-node. CLUSTER-IP est l'adresse IP interne visible uniquement au sein de votre réseau virtuel cloud. EXTERNAL-IP correspond à l'adresse IP externe avec équilibrage de charge.

Vous devez maintenant pouvoir accéder au service en utilisant l'adresse suivante dans votre navigateur : http://<EXTERNAL_IP>:8080

À ce stade, nous avons acquis plusieurs fonctionnalités en passant aux conteneurs et à Kubernetes : nous n'avons pas besoin de spécifier sur quel hôte exécuter notre charge de travail, et nous bénéficions également de la surveillance des services et du redémarrage. Voyons quels autres avantages nous pouvons tirer de notre nouvelle infrastructure Kubernetes.

Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.

Créer un service Kubernetes

Assurer le scaling de votre service

L'une des puissantes fonctionnalités de Kubernetes est le scaling de votre application, qui se fait très simplement. Imaginons que vous ayez soudain besoin d'augmenter la capacité de votre application. Vous pouvez demander au contrôleur de réplication de gérer un certain nombre de nouvelles instances dupliquées pour votre pod :

kubectl scale deployment hello-node --replicas=4

Voici le résultat que vous devez obtenir :

deployment.extensions/hello-node scaled

Vous pouvez demander la description du déploiement mis à jour :

kubectl get deployment

Voici le résultat que vous devez obtenir :

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-node   4         4         4            4           16m

Vous pouvez également répertorier tous les pods :

kubectl get pods

Voici le résultat que vous devez obtenir :

NAME                         READY     STATUS    RESTARTS   AGE
hello-node-714049816-g4azy   1/1       Running   0          1m
hello-node-714049816-rk0u6   1/1       Running   0          1m
hello-node-714049816-sh812   1/1       Running   0          1m
hello-node-714049816-ztzrb   1/1       Running   0          16m

Une approche déclarative est utilisée ici. Plutôt que de démarrer ou d'arrêter de nouvelles instances, vous déclarez le nombre d'instances à exécuter en permanence. Les boucles de réconciliation de Kubernetes veillent à ce que la réalité corresponde à votre demande et prennent des mesures si nécessaire.

Voici un schéma qui résume l'état de votre cluster Kubernetes :

Cliquez sur Vérifier ma progression ci-dessous pour vérifier votre progression dans l'atelier.

Assurer le scaling de votre service

Déployer une mise à niveau sur votre service

À un moment donné, des corrections de bugs ou de nouvelles fonctionnalités seront nécessaires sur l'application que vous avez déployée en production. Kubernetes vous aide à déployer une nouvelle version en production sans affecter les utilisateurs.

Premièrement, modifiez l'application. Modifiez server.js :

vi server.js

i

Ensuite, mettez à jour le message de réponse :

response.end("Hello Kubernetes World!");

Enregistrez le fichier server.js : appuyez sur Échap, puis saisissez :

:wq

Vous pouvez à présent créer et publier une nouvelle image de conteneur sur le registre avec une balise comportant un numéro (v2 dans cet exemple).

Exécutez la commande suivante en remplaçant PROJECT_ID par l'ID de votre projet, que vous trouverez dans la console et à la section Connection Details de cet atelier :

docker build -t gcr.io/PROJECT_ID/hello-node:v2 .

docker push gcr.io/PROJECT_ID/hello-node:v2

Kubernetes met à jour votre contrôleur de réplication de manière fluide pour installer la nouvelle version de l'application. Afin de modifier le libellé de l'image pour votre conteneur en cours d'exécution, vous devez modifier le déploiement hello-node deployment existant et remplacer l'image gcr.io/PROJECT_ID/hello-node:v1 par gcr.io/PROJECT_ID/hello-node:v2.

Pour ce faire, utilisez la commande kubectl edit. Elle permet d'ouvrir un éditeur de texte qui affiche la configuration yaml complète du déploiement. Vous n'avez pas besoin de comprendre la configuration yaml complète pour le moment. Sachez simplement qu'en mettant à jour le champ spec.template.spec.containers.image de la configuration, vous demandez au déploiement de mettre à jour les pods avec la nouvelle image.

kubectl edit deployment hello-node

Recherchez Spec > containers > image et remplacez le numéro de version par v2:

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2016-03-24T17:55:28Z
  generation: 3
  labels:
    run: hello-node
  name: hello-node
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-node
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-node
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-node
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-node:v1 ## Update this line ##
        imagePullPolicy: IfNotPresent
        name: hello-node
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

Après avoir effectué la modification, enregistrez et fermez ce fichier : appuyez sur Échap, puis saisissez :

:wq

Voici le résultat que vous devez obtenir :

deployment.extensions/hello-node edited

Exécutez la commande suivante pour mettre à jour le déploiement avec la nouvelle image.

kubectl get deployments

De nouveaux pods seront créés avec la nouvelle image et les anciens pods seront supprimés.

Voici le résultat que vous devez obtenir (vous devrez peut-être réexécuter la commande ci-dessus pour voir ce qui suit):

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-node   4         4         4            4           1h

Pendant cette opération, les utilisateurs de vos services ne devraient pas constater d'interruption. Au bout d'un moment, ils commenceront à accéder à la nouvelle version de votre application. Vous trouverez davantage d'informations sur le déploiement de mises à jour dans cette documentation.

Une fois votre cluster Kubernetes Engine configuré, nous espérons que ces fonctionnalités de déploiement, de scaling et de mise à jour offertes par Kubernetes vous aideront à vous concentrer sur l'application plutôt que sur l'infrastructure.

Tester vos connaissances

Testez vos connaissances sur Google Cloud Platform en répondant à notre quiz. (Sélectionnez plusieurs réponses.)

Félicitations !

Notre atelier pratique sur Kubernetes se termine ici. Nous n'avons fait qu'effleurer les possibilités offertes par cette technologie. Nous vous encourageons à l'explorer davantage avec vos propres pods, contrôleurs de réplication et services, mais également à vous renseigner sur les vérifications de vivacité (vérification de l'état) et à envisager d'utiliser directement l'API Kubernetes.

Suivre votre prochain atelier

Continuez sur votre lancée en suivant l'atelier Gérer des déploiements avec Kubernetes Engine ou consultez ces suggestions :

• Orchestrer le cloud avec Kubernetes

• Configurer un cluster Kubernetes privé

Étapes suivantes et informations supplémentaires

• Après cet atelier, découvrez Minikube, qui permet de configurer facilement d'un cluster Kubernetes à nœud unique à des fins de développement et de test : http://kubernetes.io/docs/getting-started-guides/minikube/.
• Kubernetes est un projet Open Source (http://kubernetes.io/) hébergé sur GitHub. Vos commentaires et contributions sont donc toujours utiles.
• Vous pouvez rester informé de l'actualité de Kubernetes sur Twitter et sur le blog de la communauté.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 4 décembre 2020

Dernier test de l'atelier : 4 décembre 2020

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.