Points de contrôle
Create a Kubernetes cluster and launch Nginx container
/ 25
Create Monolith pods and service
/ 25
Allow traffic to the monolith service on the exposed nodeport
/ 5
Adding Labels to Pods
/ 20
Creating Deployments (Auth, Hello and Frontend)
/ 25
Orchestrer le cloud avec Kubernetes (Azure)
- GSP1121
- Présentation
- Préparation
- Tâche 1 : Obtenir l'exemple de code
- Tâche 2 : Démonstration rapide de Kubernetes
- Tâche 3 : Pods
- Tâche 4 : Créer des pods
- Tâche 5 : Interagir avec des pods
- Tâche 6 : Services
- Tâche 7 : Créer un service
- Tâche 8 : Ajouter des étiquettes à un pod
- Tâche 9 : Déployer des applications avec Kubernetes
- Tâche 10 : Créer des déploiements
- Félicitations !
GSP1121
Présentation
Kubernetes est l'une des méthodes les plus utilisées par les professionnels du cloud pour déployer des applications. Vous vous êtes sans doute déjà servi d'une solution Kubernetes gérée afin de déployer des applications pour votre organisation. Voici quelques questions clés que vous pourriez vous poser lorsque vous utilisez Kubernetes pour héberger et déployer des applications :
- Quel service d'équilibrage de charge l'application nécessite-t-elle ?
- Comment l'infrastructure sous-jacente sera-t-elle gérée ?
Dans Azure, Azure Kubernetes Service (AKS) gère l'infrastructure sous-jacente pour les pods, les nœuds et la mise en réseau. AKS gère également la couche d'accès entre les composants et fournit les services Kubernetes nécessaires pour accompagner le cycle de vie de l'application.
Vous avez probablement déployé des applications sur Azure AKS via la ligne de commande à l'aide d'Azure CLI et de kubectl. Les fonctionnalités de la solution Kubernetes gérée de Google Cloud, Google Kubernetes Engine (GKE), et d'AKS sont identiques. Vous pouvez utiliser les mêmes commandes CLI kubectl avec GKE qu'avec AKS.
Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :
- Provisionner un cluster Kubernetes complet à l'aide de Kubernetes Engine
- Déployer et gérer des conteneurs Docker avec
kubectl
- Décomposer une application en microservices à l'aide des déploiements et services Kubernetes
Kubernetes est axé sur les applications. Dans cette partie de l'atelier, vous allez utiliser un exemple d'application appelé "app".
Kubernetes est un projet Open Source (disponible sur kubernetes.io) qui peut s'exécuter sur de nombreux environnements différents : ordinateurs portables, clusters multinœuds haute disponibilité, clouds publics, déploiements sur site, machines virtuelles ou solutions Bare Metal.
Pour cet atelier, l'utilisation d'un environnement géré comme Kubernetes Engine vous permet de vous familiariser avec Kubernetes plutôt que d'avoir à configurer une infrastructure sous-jacente.
Préparation
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) ;
- vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.
Démarrer l'atelier et se connecter à la console Google Cloud
-
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
-
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. -
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.
-
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. -
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.
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.
- 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 :
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.
- (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :
-
Cliquez sur Autoriser.
-
Vous devez à présent obtenir le résultat suivant :
Résultat :
- (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :
Résultat :
Exemple de résultat :
gcloud
, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.
Google Kubernetes Engine
- Dans Cloud Shell, saisissez la commande suivante pour définir la zone :
- Démarrez le cluster que vous utiliserez dans cet atelier :
gcloud container clusters get-credentials io
pour vous réauthentifier.
Tâche 1 : Obtenir l'exemple de code
- Saisissez la commande suivante dans Cloud Shell pour cloner le dépôt dans l'environnement Cloud Shell de l'atelier :
-
Créez un lien symbolique qui servira de raccourci vers le répertoire de travail :
ln -s ~/training-data-analyst/courses/ak8s/CloudBridge ~/ak8s -
Accédez au répertoire requis pour cet atelier :
cd ~/ak8s/ -
Affichez les fichiers pour voir vos éléments de travail :
L'exemple se présente de la façon suivante :
Maintenant que vous avez le code, il est temps d'essayer Kubernetes !
Tâche 2 : Démonstration rapide de Kubernetes
Pour commencer à utiliser Kubernetes, le plus simple est de saisir la commande kubectl create
.
- Exécutez-la pour lancer une instance unique du conteneur "nginx" :
Kubernetes a créé un déploiement. Nous aborderons les déploiements plus en détail ultérieurement. Pour l'instant, retenez simplement qu'ils permettent aux pods de continuer à fonctionner, même si les nœuds sur lesquels ils s'exécutent sont défaillants.
Dans Kubernetes, tous les conteneurs sont exécutés dans un pod.
- Utilisez la commande
kubectl get pods
pour afficher le conteneur "nginx" en cours d'exécution :
- Lorsque le conteneur "nginx" est en cours d'exécution, vous pouvez l'exposer hors de Kubernetes à l'aide de la commande
kubectl expose
:
Que s'est-il passé ? En arrière-plan, Kubernetes a créé un équilibreur de charge externe avec une adresse IP publique associée. Les clients qui appellent cette adresse IP publique sont redirigés vers les pods en arrière-plan. Ici, il s'agit du pod "nginx".
- Affichez les services à l'aide de la commande
kubectl get services
:
ExternalIP
pour votre service peut prendre plusieurs secondes. C'est normal. Il vous suffit d'exécuter de nouveau la commande kubectl get services
en laissant quelques secondes d'intervalle jusqu'à ce que le champ soit renseigné.
- Ajoutez l'adresse IP externe à cette commande pour appeler le conteneur "nginx" à distance :
Et voilà ! Kubernetes offre un workflow facile à utiliser et prêt à l'emploi par le biais des commandes d'exécution et d'exposition kubectl
.
Tester la tâche terminée
Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer le cluster Kubernetes et à déployer le conteneur "nginx", vous verrez une note d'évaluation s'afficher.
Maintenant que vous avez découvert Kubernetes, vous pouvez vous intéresser aux composants et aux abstractions.
Tâche 3 : Pods
Les pods sont au cœur de Kubernetes.
Ils représentent et contiennent un ou plusieurs conteneurs. En principe, si vous disposez de plusieurs conteneurs présentant une forte interdépendance, ceux-ci sont contenus dans un seul pod.
Cet exemple montre un pod comprenant les conteneurs "monolith" et "nginx".
Les pods disposent également de volumes. Les volumes sont des disques de données qui ont la même durée de vie que les pods et qui peuvent être utilisés par les conteneurs de ce pod. Les pods offrent un espace de noms partagé pour leurs contenus. Ainsi, les deux conteneurs de notre exemple de pod peuvent communiquer l'un avec l'autre, et ils partagent les volumes associés.
Les pods partagent également un espace de noms en réseau. Cela signifie qu'il existe une adresse IP par pod.
Examinons à présent les pods d'un peu plus près.
Tâche 4 : Créer des pods
Les pods peuvent être créés à l'aide de fichiers de configuration de pods. Prenons quelques minutes pour examiner le fichier de configuration du pod "monolith".
- Accédez au répertoire suivant :
- Exécutez la commande ci-dessous :
Vous obtenez le fichier de configuration ouvert comme résultat :
Quelques éléments méritent votre attention :
- Votre pod est constitué d'un conteneur ("monolith").
- Vous transmettez quelques arguments au conteneur lorsqu'il démarre.
- Vous ouvrez le port 80 pour le trafic HTTP.
- Créez le pod "monolith" à l'aide de
kubectl
:
- Examinez vos pods. Utilisez la commande
kubectl get pods
pour afficher tous les pods exécutés dans l'espace de noms par défaut :
- Une fois que le pod "monolith" est en cours d'exécution, utilisez la commande
kubectl describe
pour obtenir plus d'informations :
De nombreuses informations sur le pod "monolith" s'affichent, dont l'adresse IP du pod et le journal des événements. Ces informations vous seront utiles lors d'éventuelles procédures de dépannage.
Kubernetes permet de créer facilement des pods en les décrivant dans des fichiers de configuration et en partageant des informations à leur sujet lorsqu'ils sont en cours d'exécution. Vous êtes désormais capable de créer tous les pods requis par votre déploiement !
Tâche 5 : Interagir avec des pods
Une adresse IP privée est allouée par défaut aux pods. Ceux-ci ne sont pas accessibles depuis l'extérieur du cluster. Utilisez la commande kubectl port-forward
pour mapper un port local sur un port situé à l'intérieur du pod "monolith".
-
Ouvrez un autre terminal Cloud Shell. Vous disposez désormais de deux terminaux : un pour exécuter la commande
kubectl port-forward
et un pour exécuter des commandescurl
. -
Dans le deuxième terminal, exécutez la commande suivante pour configurer le transfert de port :
- Vous pouvez commencer à communiquer avec votre pod dans le premier terminal à l'aide de la commande
curl
:
Et voilà. Votre conteneur vous salue chaleureusement ("hello") !
- Utilisez à présent la commande
curl
pour découvrir ce qui se passe lorsque vous appelez un point de terminaison sécurisé :
Ah, il y a un petit problème !
- Essayez de vous connecter pour recevoir un jeton d'authentification émis par le pod "monolith" :
- Lorsque l'invite de connexion s'affiche, utilisez le mot de passe ultra-secret "password" pour vous connecter.
La connexion entraîne l'affichage d'un jeton JWT.
- Cloud Shell ne permet pas de copier de longues chaînes correctement. Vous devez donc créer une variable d'environnement pour le jeton.
-
Lorsque vous êtes invité à indiquer le mot de passe de l'hôte, saisissez de nouveau le mot de passe ultra-secret "password".
-
Exécutez cette commande afin de copier le jeton et de l'utiliser pour appeler le point de terminaison sécurisé à l'aide de
curl
:
Vous devez recevoir une réponse de l'application vous indiquant que tout est rentré dans l'ordre.
- Utilisez la commande
kubectl logs
pour afficher les journaux du podmonolith
.
-
Ouvrez un troisième terminal et utilisez l'option
-f
pour obtenir un flux des journaux en temps réel :
- Si vous utilisez la commande
curl
dans le premier terminal pour interagir avec le pod "monolith", vous pouvez voir que les journaux sont mis à jour (dans le troisième terminal) :
- Utilisez la commande
kubectl exec
pour exécuter un shell interactif dans le pod "monolith". Cela peut vous être utile lorsque vous souhaitez résoudre des problèmes à partir d'un conteneur :
- Par exemple, avec un shell dans le conteneur "monolith", vous pouvez tester la connectivité externe à l'aide de la commande
ping
:
- Veillez à vous déconnecter lorsque vous cessez d'utiliser ce shell interactif.
Comme vous pouvez le voir, interagir avec les pods est aussi simple que d'utiliser la commande kubectl
. Si vous devez appeler un conteneur à distance ou obtenir un shell de connexion, Kubernetes vous fournit tout ce dont vous avez besoin.
Tâche 6 : Services
Les pods ne sont pas conçus pour être persistants. Ils peuvent être arrêtés ou démarrés pour plusieurs raisons (si les vérifications d'activité ou d'aptitude échouent, par exemple), ce qui entraîne un problème :
Que se passe-t-il si vous souhaitez communiquer avec un ensemble de pods ? Quand ils redémarrent, il se peut qu'une adresse IP différente leur soit allouée.
C'est là que les services entrent en jeu. Ils fournissent des points de terminaison stables pour les pods.
Les services utilisent des étiquettes pour déterminer les pods qu'ils gèrent. Si les pods sont correctement étiquetés, ils sont automatiquement sélectionnés et exposés par les services.
Le niveau d'accès fourni par un service à un ensemble de pods dépend du type de service. À l'heure actuelle, il existe trois types de services :
-
ClusterIP
(interne) est le type de service par défaut qui n'est visible qu'au sein du cluster. -
NodePort
attribue une adresse IP accessible en externe à chaque nœud du cluster. -
LoadBalancer
ajoute un équilibreur de charge (provenant du fournisseur de cloud) qui transfère le trafic du service aux nœuds contenus dans celui-ci.
Vous allez maintenant apprendre à :
- créer un service ;
- utiliser des sélecteurs d'étiquettes pour exposer un ensemble limité de pods en externe.
Tâche 7 : Créer un service
Au préalable, vous devez créer un pod sécurisé capable de gérer le trafic HTTPS.
- Si vous avez changé de répertoire, veillez à bien revenir au répertoire
~/orchestrate-with-kubernetes/kubernetes
:
- Examinez le fichier de configuration du service monolith :
- Créez le type de pod "secure-monolith" et ses données de configuration :
Vous disposez désormais d'un pod sécurisé. Vous allez maintenant exposer le pod "secure-monolith" en externe. Pour ce faire, créez un service Kubernetes.
- Examinez le fichier de configuration du service monolith :
(Résultat)
* Un sélecteur est utilisé pour trouver et exposer automatiquement tous les pods dotés des étiquettes "app: monolith" et "secure: enabled".
* Vous devez à présent exposer le port du nœud de sorte que le trafic externe du port 31000 soit transféré vers "nginx" (sur le port 443).
- Utilisez la commande
kubectl create
pour créer le service monolith à partir du fichier de configuration du service monolith :
(Résultat)
Tester la tâche terminée
Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer les pods et le service monolith, vous verrez une note d'évaluation s'afficher.
Vous utilisez un port pour exposer le service. En d'autres termes, des conflits de ports risquent de se produire si une autre application essaie de s'associer au port 31000 sur l'un de vos serveurs.
En temps normal, c'est Kubernetes qui gère l'affectation de ce port. Mais pour cet atelier, vous avez choisi un port afin de simplifier la configuration ultérieure des vérifications de l'état.
- Utilisez la commande
gcloud compute firewall-rules
pour autoriser le trafic vers le service monolith sur le port exposé du nœud :
Tester la tâche terminée
Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer la règle de pare-feu autorisant le trafic TCP sur le port 31000, vous verrez une note d'évaluation s'afficher.
Maintenant que la configuration est terminée, vous devez pouvoir appeler le service secure-monolith depuis l'extérieur du cluster sans utiliser le transfert de port.
- Commencez par récupérer une adresse IP externe pour l'un des nœuds.
- Essayez à présent d'appeler le service secure-monolith à l'aide de la commande
curl
:
Petit problème… La requête a expiré. Que se passe-t-il ?
Remarque : Il est temps de tester rapidement vos connaissances.
Utilisez les commandes suivantes pour répondre aux questions ci-dessous :kubectl get services monolith
kubectl describe services monolith
Questions :
Indice : Le problème est lié aux étiquettes. Vous le résoudrez dans la prochaine section.
Tâche 8 : Ajouter des étiquettes à un pod
À l'heure actuelle, le service monolith ne dispose d'aucun point de terminaison. Pour résoudre un problème de ce type, vous pouvez par exemple utiliser la commande kubectl get pods
avec une requête d'étiquette.
- Vous pouvez voir que plusieurs pods en cours d'exécution portent l'étiquette "monolith".
- Qu'en est-il des étiquettes "app=monolith" et "secure=enabled" ?
Vous remarquerez que cette requête d'étiquette ne renvoie aucun résultat. Tout semble indiquer que vous devez ajouter l'étiquette "secure=enabled" à certains pods.
- Utilisez la commande
kubectl label
pour ajouter l'étiquettesecure=enabled
manquante au pod "secure-monolith". Vous pouvez ensuite vérifier et constater que les étiquettes ont été mises à jour.
- Maintenant que les étiquettes des pods sont correctes, affichez la liste des points de terminaison sur le service monolith :
Il y en a un !
- Testez-le en appelant de nouveau l'un des nœuds.
Ça y est ! Mission accomplie.
Tester la tâche terminée
Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à ajouter les étiquettes aux pods "monolith", vous verrez une note d'évaluation s'afficher.
Tâche 9 : Déployer des applications avec Kubernetes
L'objectif de cet atelier est de vous préparer au scaling et à la gestion des conteneurs en production. C'est là que les déploiements entrent en jeu. Il s'agit d'une méthode déclarative permettant de veiller à ce que le nombre de pods en cours d'exécution corresponde au nombre de pods souhaité (spécifié par l'utilisateur).
Le principal avantage des déploiements est de supprimer les tâches de bas niveau de la gestion des pods. Ils utilisent des ensembles d'instances répliquées en arrière-plan pour gérer le démarrage et l'arrêt des pods. Lorsque c'est nécessaire, les déploiements gèrent la mise à jour et le scaling des pods. Ils gèrent également le redémarrage des pods en cas d'arrêt.
Prenons un exemple simple :
Les pods sont conditionnés par la durée de vie du nœud sur lequel ils sont créés. Dans l'exemple ci-dessus, Node3 s'est arrêté (en entraînant également l'arrêt d'un pod). Vous n'avez pas eu à créer manuellement un pod et à lui trouver un nœud. Votre déploiement s'est chargé de créer un pod et de le démarrer sur Node2.
Plutôt pratique !
Il est temps de mettre à profit toutes vos nouvelles connaissances sur les pods et services pour décomposer l'application monolith en services plus petits à l'aide de déploiements.
Tâche 10 : Créer des déploiements
Vous allez décomposer l'application monolith en trois parties distinctes :
- auth, qui génère des jetons JWT pour les utilisateurs authentifiés
- hello, qui salue les utilisateurs authentifiés
- frontend, qui achemine le trafic vers les services auth et hello
Vous êtes prêt à créer des déploiements, un pour chaque service. Lorsque ce sera fait, vous définirez des services internes pour les déploiements auth et hello, ainsi qu'un service externe pour le déploiement frontend. Une fois ces services définis, vous pourrez interagir avec les microservices de la même manière qu'avec monolith, à ceci près que vous pourrez faire évoluer et déployer chaque partie indépendamment.
- Commencez par examiner le fichier de configuration de déploiement du service auth.
(Résultat)
Le déploiement crée une instance répliquée, et vous utilisez la version 2.0.0 du conteneur "auth".
En exécutant la commande kubectl create
pour créer le déploiement auth, vous créez un pod conforme aux données du fichier manifeste du déploiement. Vous pouvez donc faire évoluer le nombre de pods en modifiant le nombre spécifié dans le champ "Instances répliquées".
- Poursuivez en créant l'objet de déploiement :
- Vous devez maintenant créer un service pour votre déploiement auth. Utilisez la commande
kubectl create
pour créer le service auth :
- Procédez de la même façon pour créer et exposer le déploiement hello :
- Répétez l'opération encore une fois pour créer et exposer le déploiement frontend :
- Pour interagir avec le service frontend, capturez son adresse IP externe, puis appelez-le avec curl :
EXTERNAL-IP
est à l'état d'attente.Vous obtenez la réponse "hello" !
Tester la tâche terminée
Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer les déploiements auth, hello et frontend, vous verrez une note d'évaluation s'afficher.
Félicitations !
Vous avez développé une application multiservice à l'aide de Kubernetes. Les compétences que vous avez acquises lors de cet atelier vous permettront de déployer des applications complexes sur Kubernetes avec un ensemble de déploiements et de services.
Passons en revue les similitudes et les différences entre les deux plates-formes que vous avez constatées dans l'atelier.
Similitudes :
- Le processus de configuration et de déploiement d'une application sur GKE est très semblable à celui sur Azure AKS.
- Les deux services utilisent les commandes kubectl et acceptent les Dockerfiles.
- Comme pour AKS, GKE gère l'infrastructure sous-jacente et fournit des services Kubernetes.
Différences :
- Au fur et à mesure que vous apprendrez à utiliser GKE, vous remarquerez certaines différences par rapport à AKS. Par exemple, GKE offre le mode de fonctionnement Autopilot, qui permet une configuration simplifiée en respectant les pratiques recommandées par Google.
- En termes de réseau, AKS utilise le réseau virtuel Azure et le plug-in Azure Container Network Interface. Ce plug-in permet de fournir des adresses IP de réseau virtuel pour chaque pod. Les pods peuvent accéder directement à d'autres services qui se trouvent sous les points de terminaison du service de réseau virtuel. Dans Google Cloud, le modèle de réseau Kubernetes s'appuie en grande partie sur les adresses IP. Les services, les pods, les conteneurs et les nœuds communiquent via des adresses IP et des ports.
Terminer votre quête
Cet atelier d'auto-formation fait partie de la quête Build Google Cloud Infrastructure for Azure Professionals. Une quête est une série d'ateliers associés qui constituent un parcours de formation. Si vous terminez cette quête, vous obtenez un badge attestant de votre réussite. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à n'importe quelle quête contenant cet atelier pour obtenir immédiatement les crédits associés. Découvrez toutes les quêtes disponibles dans le catalogue Google Cloud Skills Boost.
Atelier suivant
Poursuivez votre quête avec l'atelier Hébergement d'une application Web sur Google Cloud à l'aide de Compute Engine.
Étapes suivantes et informations supplémentaires
- Vous pouvez vous tenir informé de l'actualité de Kubernetes sur Twitter et sur le blog de la communauté.
- N'oubliez pas que Kubernetes est un projet Open Source (http://kubernetes.io/) hébergé sur GitHub. Vos commentaires et contributions sont donc toujours utiles.
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 modification du manuel : 30 octobre 2023
Dernier test de l'atelier : 30 octobre 2023
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.