Déployer une application ASP.NET Core dans Kubernetes sur Google Kubernetes Engine

1. Présentation

ASP.NET Core est un nouveau framework Open Source et multiplate-forme, qui permet de développer en C# des applications modernes basées sur le cloud et connectées à Internet.

Kubernetes est un projet Open Source qui peut s'exécuter dans de nombreux environnements différents : des ordinateurs portables aux clusters multinœuds à haute disponibilité, des clouds publics aux déploiements sur site, des machines virtuelles aux machines dédiées.

Dans cet atelier, vous allez déployer sur Kubernetes une application ASP.NET Core simple qui s'exécute sur Kubernetes Engine. Cet atelier de programmation fait suite à l'atelier de programmation Créer et lancer une application ASP.NET Core depuis Google Cloud Shell. Nous vous conseillons de l'avoir suivi avant d'entamer celui-ci.

Le but de cet atelier de programmation est de vous permettre de transformer votre code (dans cet exemple, une simple application Hello World" ASP.NET Core) en une application dupliquée s'exécutant sur Kubernetes. Vous allez transformer le code que vous avez développé sur votre machine en une image de conteneur Docker, que vous exécuterez ensuite sur Google Kubernetes Engine.

Voici un schéma des interactions entre les différents éléments de cet atelier de programmation. Utilisez ce schéma comme référence au fur et à mesure de votre progression dans l'atelier de programmation. Il prendra tout son sens à la fin de l'atelier. Pour l'instant, vous pouvez le laisser de côté.

Pour cet atelier de programmation, 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 permet de vous consacrer à la découverte de Kubernetes plutôt que d'avoir à configurer l'infrastructure sous-jacente.

Si vous souhaitez exécuter Kubernetes sur votre appareil local, par exemple votre ordinateur portable de développement, n'hésitez pas à utiliser Minikube. Il permet de configurer facilement un cluster Kubernetes à nœud unique à des fins de développement et de test. Si vous le souhaitez, vous pouvez utiliser Minikube dans cet atelier de programmation.

Points abordés

• Empaqueter une application simple ASP.NET Core en tant que conteneur Docker
• Créer un cluster Kubernetes sur Google Kubernetes Engine (GKE)
• Déployer une application ASP.NET Core sur un pod
• Autoriser le trafic externe vers un pod
• Effectuer un scaling à la hausse et déployer une mise à niveau de votre service
• Exécuter le tableau de bord graphique de Kubernetes

Prérequis

• Un navigateur tel que Chrome ou Firefox

Comment allez-vous utiliser ce tutoriel ?

Je vais le lire uniquement Je vais le lire et effectuer les exercices

Quel est votre niveau d'expérience avec Google Cloud Platform ?

Débutant Intermédiaire Expert

2. Préparation

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. (Si vous ne possédez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.)

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pouvez le modifier à tout moment.
• L'ID du projet doit être unique sur l'ensemble des projets Google Cloud et doit être immuable (vous ne pouvez pas le modifier une fois que vous l'avez défini). La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID du projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet doit être unique au niveau mondial. Personne d'autre ne peut l'employer une fois que vous l'avez sélectionné. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement pertinent pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300$.

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Activer Cloud Shell

1. Dans Cloud Console, cliquez sur Activer Cloud Shell .

Si vous n'avez jamais démarré Cloud Shell auparavant, un écran intermédiaire s'affiche en dessous de la ligne de flottaison, décrivant de quoi il s'agit. Si tel est le cas, cliquez sur Continuer. Cet écran ne s'affiche qu'une seule fois. Voici à quoi il ressemble :

Le provisionnement et la connexion à Cloud Shell ne devraient pas prendre plus de quelques minutes.

Cette machine virtuelle contient tous les outils de développement dont vous avez besoin. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez réaliser une grande partie, voire la totalité, des activités de cet atelier dans un simple navigateur ou sur votre Chromebook.

Une fois connecté à Cloud Shell, vous êtes en principe authentifié et le projet est défini avec votre ID de projet.

2. Exécutez la commande suivante dans Cloud Shell pour vérifier que vous êtes authentifié :

gcloud auth list

Résultat de la commande

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

Remarque : gcloud est l'outil de ligne de commande performant et unifié de Google Cloud. Il est préinstallé dans Cloud Shell. Il est également compatible avec la saisie semi-automatique via la touche de tabulation. Pour en savoir plus, consultez la section de présentation de l'outil de ligne de commande gcloud.

3. Exécutez la commande suivante dans Cloud Shell pour vérifier que la commande gcloud connaît votre projet :

gcloud config list project

Résultat de la commande

[core]
project = <PROJECT_ID>

Si vous obtenez un résultat différent, exécutez cette commande :

gcloud config set project <PROJECT_ID>

Résultat de la commande

Updated property [core/project].

3. Créer une application ASP.NET Core dans Cloud Shell

Dans l'invite Cloud Shell, vous pouvez vérifier que l'outil de ligne de commande dotnet est déjà installé en vérifiant sa version. La version de l'outil de ligne de commande dotnet installé devrait s'afficher :

dotnet --version

Ensuite, créez le squelette d'une application Web ASP.NET Core.

dotnet new mvc -o HelloWorldAspNetCore

Cette action créera un projet et restaurera ses dépendances. Un message de ce type doit s'afficher :

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. Exécuter l'application ASP.NET Core

Nous allons bientôt pouvoir exécuter l'application. Accédez au dossier de l'application.

cd HelloWorldAspNetCore

Enfin, exécutez l'application.

dotnet run --urls=http://localhost:8080

L'application commence à écouter sur le port 8080.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

Pour vérifier que l'application est bien en cours d'exécution, cliquez sur le bouton "Aperçu sur le Web" en haut à droite, puis sélectionnez "Prévisualiser sur le port 8080".

La page Web ASP.NET Core par défaut s'affiche :

Une fois que vous avez vérifié que l'application est en cours d'exécution, appuyez sur Ctrl+C pour l'arrêter.

5. Empaqueter l'application ASP.NET Core en tant que conteneur Docker

Préparez ensuite votre application à s'exécuter en tant que conteneur. La première étape consiste à définir le conteneur et son contenu.

Dans le répertoire de base de l'application, créez un fichier Dockerfile pour définir l'image Docker.

touch Dockerfile

À l'aide de l'éditeur de votre choix (vim,, nano,emacs ou l'éditeur de code Cloud Shell), ajoutez ce qui suit à Dockerfile.

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

Une des configurations importantes du fichier Dockerfile est le port 8080 sur lequel l'application écoute le trafic entrant. Pour ce faire, vous devez définir la variable d'environnement ASPNETCORE_URLS, qui permet aux applications ASP.NET Core de déterminer le port d'écoute.

Enregistrez ce Dockerfile. À présent, créons l'image :

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

Une fois cette opération terminée (le téléchargement et l'extraction de tous les éléments peuvent prendre un peu de temps), vous pouvez voir que l'image est créée et enregistrée localement :

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1            

Testez l'image en local avec la commande suivante, qui exécutera un conteneur Docker en local sur le port 8080 à partir de l'image de conteneur que vous venez de créer :

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Exploitez une fois de plus la fonctionnalité d'aperçu sur le Web de Cloud Shell :

La page Web ASP.NET Core par défaut devrait s'afficher dans un nouvel onglet.

Une fois que vous avez vérifié que l'application s'exécute correctement en local dans un conteneur Docker, vous pouvez arrêter le conteneur en cours d'exécution en saisissant Ctrl-> C.

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 depuis tous les projets Google Cloud (mais également en dehors de Google Cloud Platform).

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

Si tout se passe bien, vous devriez voir l'image de conteneur listée dans la section Container Registry au bout de quelques instants. Vous disposez maintenant d'une image Docker pour l'ensemble du projet. Comme vous le verrez dans quelques minutes, vous pouvez accéder à cette image et l'orchestrer grâce à Kubernetes.

Dans cet exemple, nous avons utilisé un domaine générique pour le registre (gcr.io). Mais si vous le souhaitez, vous pouvez préciser la zone et le bucket à utiliser. Pour en savoir plus, consultez la page https://cloud.google.com/container-registry/docs/#pushing_to_the_registry.

Si vous êtes curieux, vous pouvez parcourir les images de conteneurs stockées dans Google Cloud Storage en cliquant sur ce lien : https://console.cloud.google.com/storage/browser/ (le lien généré doit se présenter sous la forme suivante : https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. Créer un cluster Kubernetes

Vous êtes maintenant prêt à créer votre cluster GKE. Mais avant cela, accédez à la section Google Kubernetes Engine de la console Web et attendez que le système s'initialise (cela ne devrait prendre que quelques secondes).

Un cluster se compose d'un serveur d'API maître Kubernetes géré par Google et d'un ensemble de nœuds de calcul. Les nœuds de calcul sont des machines virtuelles Compute Engine.

Utilisons la CLI gcloud depuis votre session Cloud Shell pour créer un cluster. Définissez votre zone sur une zone proche de vous ( liste des zones). Cette opération prendra quelques minutes :

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

Une fois l'opération terminée, vous devez voir le cluster créé.

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

Vous pouvez également créer ce cluster via la console présentée ci-dessus : Compute > Kubernetes Engine > Clusters de conteneurs > Créer un cluster de conteneurs.

Même si ce n'est pas obligatoire, il est recommandé de créer le cluster dans la même zone que le bucket de stockage utilisé par le registre de conteneurs (voir étape précédente).

Vous devez maintenant disposer d'un cluster Kubernetes entièrement fonctionnel, fourni par Google Kubernetes Engine :

Vous pouvez à présent déployer votre application conteneurisée sur le cluster Kubernetes. À partir de maintenant, vous utiliserez la ligne de commande kubectl (déjà configurée dans votre environnement Cloud Shell). Dans la suite de cet atelier de programmation, vous devrez utiliser les versions client et serveur 1.2 ou ultérieures de Kubernetes. kubectl version affiche la version actuelle de la commande.

7. Créer un déploiement

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

Créez un fichier hello-dotnet.yaml à l'aide de votre éditeur préféré (vim, nano,emacs ou l'éditeur de code Cloud Shell) et définissez le déploiement Kubernetes pour le pod :

Veillez à remplacer YOUR-PROJECT-ID par l'ID de votre projet.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

Déployez sur l'espace de noms par défaut avec kubectl :

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet 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-dotnet:v1.

Pour afficher le déploiement que vous venez de créer, exécutez simplement la commande suivante :

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

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

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-ztzrb   1/1       Running   0          57s

Il est temps à présent de découvrir quelques commandes kubectl intéressantes (aucune de ces commandes ne modifie l'état du cluster, la documentation complète est disponible ici) :

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

À ce stade, votre conteneur devrait être sous le contrôle de Kubernetes, mais vous devez quand même le rendre accessible depuis l'extérieur.

8. 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-dotnet accessible en dehors du réseau virtuel Kubernetes, vous devez exposer le pod en tant que service Kubernetes.

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

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

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 répliqué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 lister tous les services du cluster :

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Remarquez que deux adresses IP accessibles par le port 8080 sont répertoriées pour votre service. L'une est l'adresse IP interne visible uniquement au sein de votre réseau virtuel cloud. L'autre correspond à l'adresse IP externe avec équilibrage de charge. Dans cet exemple, l'adresse IP externe est 104.155.20.69.

La disponibilité et la visibilité de l'EXTERNAL-IP peuvent nécessiter quelques minutes. Si EXTERNAL-IP ne s'affiche pas, patientez quelques minutes, puis réessayez.

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

À ce stade, vous avez gagné plusieurs fonctionnalités en passant aux conteneurs et à Kubernetes. Vous n'avez pas besoin de spécifier sur quel hôte exécuter votre charge de travail. Vous bénéficiez également de la surveillance et du redémarrage des services. Voyons quels autres avantages vous pouvez tirer de votre nouvelle infrastructure Kubernetes.

9. Faire évoluer votre service

Le scaling des applications, qui est une puissante fonctionnalité de Kubernetes, est simple à mettre en œuvre. Imaginons que vous ayez soudainement besoin d'augmenter la capacité de votre application. Vous pouvez simplement demander au contrôleur de réplication de gérer un certain nombre de nouvelles instances répliquées pour votre pod :

kubectl scale deployment hello-dotnet --replicas=4

kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         4         4            3           16m

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

Notez que la programmation déclarative est utilisée dans cet exemple : 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 :

Vous pouvez également réduire très facilement la taille de votre service. Voici comment passer de quatre à deux pods.

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. Tester la résilience

Kubernetes (ou plus précisément ReplicaSet) surveille vos pods. Si un problème survient et qu'un pod tombe en panne, il en crée immédiatement un autre. Testons cela pour voir comment ça fonctionne.

Commencez par obtenir la liste des pods :

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

Supprimez l'un des pods en transmettant son nom :

kubectl delete pod hello-dotnet-714049816-g4azy

Si vous consultez à nouveau la liste des pods, vous verrez qu'un nouveau pod est en cours de création et d'exécution immédiatement :

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. Déployer une mise à niveau sur votre service

À un moment donné, l'application que vous avez déployée en production nécessitera des corrections de bugs ou l'ajout de nouvelles fonctionnalités. Voyons à quoi ressemble ce processus.

Commençons par modifier l'application. Ouvrez l'éditeur de code depuis Cloud Shell.

Accédez à Index.cshtml sous HelloWorldAspNetCore > Views > Home et mettez à jour l'un des messages du carrousel.

Recherchez la ligne suivante :

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core 

Remplacez-le par le message suivant :

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

Enregistrez les modifications, puis revenez à Cloud Shell. Dans HelloWorldAspNetCore,, créez l'image Docker :

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 . 

Puis, transférez-la vers Container Registry :

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 

La création et le transfert de cette image mise à jour doivent être beaucoup plus rapides grâce à la mise en cache.

Vous êtes maintenant prêt à ce que Kubernetes mette à jour votre contrôleur de réplication de manière fluide et installe 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 hello-dotnet deployment existant et remplacer l'image gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 par gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2.

Pour ce faire, vous utiliserez la commande kubectl edit. Un éditeur de texte s'ouvre et 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-dotnet

# 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: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        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 le fichier (vous utilisez vi, appuyez donc sur Échap, puis saisissez :wq et appuyez sur la touche Entrée).

deployment "hello-dotnet" edited

Le déploiement est mis à jour avec la nouvelle image, ce qui entraîne la création de nouveaux pods avec la nouvelle image et la suppression des anciens pods.

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

Pendant cette opération, les utilisateurs des services ne devraient pas constater d'interruption. Au bout d'un moment, ils commenceront à accéder à la nouvelle version de votre application.

Pour en savoir plus sur les mises à jour progressives, consultez la documentation Kubernetes.

Une fois votre environnement configuré (le cluster GKE/Kubernetes dans cet exemple), 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.

12. Cloud Build

Jusqu'à présent, nous avons créé des conteneurs avec des commandes Docker standards (docker build …), puis nous avons transféré manuellement l'image dans Container Registry de Google Cloud Platform. Il est également possible de différer les deux étapes côté serveur Cloud Build, qui peut créer et envoyer l'image de conteneur sans installation locale de Docker.

Tout d'abord, activez l'API Cloud Build dans Gestionnaire d'API > Bibliothèque. Recherchez Cloud Build, puis cliquez sur API Cloud Build :

Si ce n'est pas déjà fait, cliquez sur Activer l'API. Au final, l'API devrait être activée comme suit :

Une fois l'API Cloud Build activée, vous pouvez exécuter la commande suivante pour créer et transférer votre image à partir du service Container Builder :

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

L'image est automatiquement stockée dans Container Registry.

13. Exécuter le tableau de bord graphique de Kubernetes

Une interface utilisateur graphique Web (tableau de bord) a été ajoutée dans les dernières versions de Kubernetes. Cette interface utilisateur vous permet de vous lancer rapidement et inclut certaines fonctionnalités de l'interface de ligne de commande afin d'interagir avec le système de manière plus accessible et intuitive.

Pour configurer l'accès au tableau de bord des clusters Kubernetes, saisissez les commandes suivantes dans la fenêtre Cloud Shell :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

Utilisez ensuite à nouveau la fonctionnalité d'aperçu de Cloud Shell pour accéder au port 8081 :

Vous devez être redirigé vers le point de terminaison de l'API. Il est possible que vous soyez redirigé vers une page "Non autorisé", mais ne vous inquiétez pas. Pour accéder au tableau de bord, supprimez "?authuser=3" et remplacez-le par "/ui".

Profitez du tableau de bord graphique de Kubernetes et utilisez-le pour déployer des applications en conteneur ainsi que pour surveiller et gérer vos clusters.

Vous pouvez également accéder au tableau de bord à partir d'une machine de développement ou d'une machine locale en vous servant d'instructions similaires. Pour ce faire, à partir de la console Web, appuyez sur le bouton "Connect" (Connexion) pour le cluster que vous souhaitez surveiller.

Une fois que vous avez fini avec le tableau de bord, vous pouvez appuyer sur Ctrl+C pour arrêter le proxy. Pour en savoir plus sur le tableau de bord Kubernetes, suivez la visite guidée du tableau de bord.

14. Journalisation

Vous pouvez utiliser la commande kubectl logs pour récupérer les journaux d'un conteneur en cours d'exécution dans Kubernetes. Lorsque vous utilisez Google Kubernetes Engine pour exécuter des clusters Kubernetes gérés, tous les journaux sont automatiquement transférés et stockés dans Google Cloud Logging. Pour afficher tous les journaux des pods, accédez à Stackdriver → Logging → Journaux dans la console Google Cloud :

Une fois dans la console de journalisation, vous pouvez accéder à Conteneur GKE pour afficher tous les journaux collectés à partir de STDOUT :

À partir de là, vous pouvez éventuellement exporter les journaux dans Google BigQuery pour une analyse plus approfondie ou configurer des alertes basées sur les journaux. Nous n'aurons pas le temps de le faire pendant l'atelier d'aujourd'hui.

15. Félicitations !

Cet atelier de programmation qui a permis de présenter ASP.NET Core et Kubernetes de manière simplifiée est à présent terminé. 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 l'activité (ou de l'état) et à envisager d'utiliser directement l'API Kubernetes.

Effectuer un nettoyage

Et voilà ! Vous devez désormais nettoyer les ressources utilisées pour limiter vos dépenses et avoir un comportement responsable dans le cloud.

Supprimez le déploiement (ce qui supprime également les pods en cours d'exécution) et le service (ce qui supprime également votre équilibreur de charge externe) :

Commencez par supprimer le service et le déploiement, ce qui supprime également votre équilibreur de charge externe :

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

Ensuite, supprimez votre cluster :

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

Cette opération supprime toutes les instances Google Compute Engine qui exécutent le cluster.

Enfin, supprimez le bucket de stockage du registre Docker qui héberge vos images :

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Bien sûr, vous pouvez également supprimer l'intégralité du projet, mais vous perdrez toute configuration de facturation que vous avez effectuée (vous devez d'abord désactiver la facturation du projet). De plus, la suppression d'un projet n'arrête la facturation qu'à la fin du cycle de facturation en cours.

Points abordés

• Empaqueter une application simple ASP.NET Core en tant que conteneur Docker
• Créer un cluster Kubernetes sur Google Kubernetes Engine
• Déployer une application ASP.NET Core sur un pod
• Autoriser le trafic externe vers un pod
• Effectuer un scaling à la hausse et déployer une mise à niveau de votre service
• Exécuter le tableau de bord graphique de Kubernetes

Étapes suivantes

• Obtenez plus d'informations sur Kubernetes (http://kubernetes.io/).
• Obtenez plus d'informations sur Windows sur Google Cloud Platform.
• Obtenez plus d'informations sur .NET sur Google Cloud Platform.
• Obtenez plus d'informations sur SQL Server sur Google Cloud Platform.
• Obtenez plus d'informations sur Cloud Tools pour Visual Studio.
• Obtenez plus d'informations sur Cloud Tools pour PowerShell.

Licence

Ce document est publié sous une licence Creative Commons Attribution 2.0 Generic.