Cette page a été traduite par l'API Cloud Translation.

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 dans Kubernetes une application ASP.NET Core simple qui s'exécute sur Kubernetes Engine. Cet atelier de programmation s'appuie sur l'atelier de programmation Créer et lancer une application ASP.NET Core depuis Google Cloud Shell. Nous vous conseillons de suivre cet atelier avant de vous lancer.

L'objectif de cet atelier de programmation est de transformer votre code (une simple application Hello World ASP.NET Core ici) en une application répliquée s'exécutant sur Kubernetes. Vous allez convertir le code que vous avez développé sur votre machine en une image de conteneur Docker, puis exécuter cette image sur Google Kubernetes Engine.

Voici un schéma des différentes parties de cet atelier de programmation pour vous aider à comprendre comment les éléments s'assemblent. Utilisez-le comme référence tout au long de l'atelier de programmation. Tout devrait avoir du sens à la fin (mais n'hésitez pas à ignorer cela pour l'instant).

Pour les besoins de cet atelier de programmation, l'utilisation d'un environnement géré tel que Kubernetes Engine (une version de Kubernetes hébergée par Google et exécutée sur Compute Engine) vous permet de vous concentrer davantage sur l'utilisation de Kubernetes plutôt que sur la configuration de 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 pour suivre 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 ?

<ph type="x-smartling-placeholder"></ph> Débutant

Intermédiaire

Expert

2. Préparation

Configuration de l'environnement au rythme de chacun

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. généralement, vous ne vous souciez pas de ce que c’est. Dans la plupart des ateliers de programmation, vous devrez référencer l'ID du projet (il est généralement identifié comme PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre au hasard. Vous pouvez également essayer la vôtre pour voir si elle est disponible. Il ne peut pas être modifié après cette étape et restera actif pendant toute la durée du projet.
Pour votre information, il existe une troisième valeur, le numéro de projet, utilisé par certaines API. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

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 arrêter les ressources afin d'éviter que des frais ne vous soient facturés au-delà de ce tutoriel, vous pouvez supprimer les ressources que vous avez créées ou l'ensemble du projet. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai gratuit 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

Dans Cloud Console, cliquez sur Activer Cloud Shell .

Si vous n'avez jamais démarré Cloud Shell auparavant, un écran intermédiaire (en dessous de la ligne de flottaison) vous explique de quoi il s'agit. Dans ce cas, cliquez sur Continuer (elle ne s'affichera plus). 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.

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`

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 une application Web squelette 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 sommes presque prêts à exécuter notre 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:

Après avoir vérifié que l'application est en cours d'exécution, appuyez sur Ctrl+C pour la fermer.

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

Préparez ensuite votre application pour qu'elle s'exécute 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 Dockerfile pour définir l'image Docker.

touch Dockerfile

Ajoutez le code suivant à Dockerfile à l'aide de l'éditeur de votre choix (vim, nano,emacs ou l'éditeur de code de Cloud Shell).

# 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, définissez la variable d'environnement ASPNETCORE_URLS, que les applications ASP.NET Core utilisent pour déterminer le port à écouter.

Enregistrez ce Dockerfile. Créons maintenant l'image:

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

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

docker images

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

Testez l'image localement à l'aide de la commande suivante, qui exécutera un conteneur Docker localement 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

Profitez également de la fonctionnalité d'aperçu sur le Web de Cloud Shell :

Capture d'écran du 03/11/2015 17:20:22.png

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

Une fois que vous avez vérifié que l'application fonctionne correctement localement dans un conteneur Docker, vous pouvez arrêter le conteneur en cours d'exécution à l'aide de la commande 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 déroule comme prévu, l'image de conteneur doit s'afficher dans la section Container Registry au bout de quelques instants. À ce stade, vous disposez désormais d'une image Docker disponible à l'échelle du projet, que Kubernetes peut consulter et orchestrer, comme vous le verrez dans quelques minutes.

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 complet obtenu 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 auparavant, 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 correspondent à des machines virtuelles Compute Engine.

Utilisons la CLI gcloud de votre session Cloud Shell pour créer un cluster. Réglez votre zone sur une position proche de vous ( voir la liste des zones). Cette opération prend 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 devriez maintenant disposer d'un cluster Kubernetes entièrement fonctionnel, optimisé 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). Pour le reste de cet atelier de programmation, les versions du client et du serveur Kubernetes doivent être la version 1.2 ou ultérieure. 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. Ici, vous utiliserez simplement un conteneur créé avec votre image ASP.NET Core stockée dans votre registre de conteneurs privé. Il diffusera du contenu sur le port 8080.

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

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. Ici, 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

C'est le moment idéal pour passer en revue quelques commandes kubectl intéressantes (aucune d'entre elles ne modifiera l'état du cluster, consultez la documentation complète ici):

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

À ce stade, votre conteneur doit s'exécuter 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 depuis l'extérieur du réseau virtuel Kubernetes, vous devez exposer le pod en tant que service Kubernetes.

Depuis Cloud Shell, vous pouvez exposer le pod à l'Internet public à l'aide de 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 simplement à kubectl de répertorier 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

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

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

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

9. Effectuer le scaling de votre service

Le scaling des applications, qui est une puissante fonctionnalité de Kubernetes, est simple à mettre en œuvre. Supposons que vous ayez soudainement besoin de davantage de capacité pour votre application. vous pouvez simplement demander au contrôleur de réplication de gérer un nouveau nombre d'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 l'approche déclarative utilisée ici : au lieu de démarrer ou d'arrêter de nouvelles instances, vous déclarez le nombre d'instances devant être en cours d'exécution. Les boucles de rapprochement Kubernetes permettent simplement de s'assurer que la réalité correspond à votre demande et de prendre des mesures si nécessaire.

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

Vous pouvez également très facilement effectuer un scaling à la baisse de votre service. Voici comment passer de quatre pods à 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. Résilience aux tests

Kubernetes (ou, plus précisément, ReplicaSet) surveille vos pods. Si un problème survient avec le pod et qu'il tombe en panne, il en crée un immédiatement. Testons cela et voyons comment cela 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 le nom du pod:

kubectl delete pod hello-dotnet-714049816-g4azy

Si vous consultez à nouveau la liste des pods, vous verrez qu'un nouveau pod est créé et s'exécute 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 à partir de 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 .

Transférez ensuite les données vers Container Registry:

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

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. Pour modifier le libellé de l'image pour votre conteneur en cours d'exécution, vous devez modifier le fichier 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, utilisez la commande kubectl edit. Un éditeur de texte s'ouvre et affiche la configuration yaml complète du déploiement. Il n'est pas nécessaire 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 afin qu'ils utilisent 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 (pour utiliser vi, appuyez sur "Échap", puis saisissez :wq et appuyez sur la touche "Entrée").

deployment "hello-dotnet" edited

Cette opération met à jour le déploiement 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 de Kubernetes.

Nous espérons que ces fonctionnalités de déploiement, de scaling et de mise à jour vous conviendront qu'une fois votre environnement configuré (votre cluster GKE/Kubernetes ici), Kubernetes peut vous aider à vous concentrer sur votre application plutôt que sur la gestion de l'infrastructure.

12. Cloud Build

Jusqu'à présent, nous avons créé des conteneurs à l'aide de commandes Docker standards (docker build ...), puis nous avons transféré manuellement l'image vers Container Registry de Google Cloud Platform. Il est également possible de reporter les deux étapes au serveur Cloud Build, qui peut créer et transférer l'image de conteneur sans avoir à installer Docker en local.

Commencez par activer l'API Cloud Build dans le Gestionnaire d'API > Bibliothèque. Recherchez Cloud Build, puis cliquez sur API Cloud Build:

Cliquez sur Activer l'API si ce n'est pas déjà fait. Au final, vous devriez voir l'API 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 du cluster 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

Ensuite, utilisez à 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 se peut que la mention "Non autorisé" s'affiche mais ne vous inquiétez pas à ce sujet. 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 suivant les mêmes instructions. Pour cela, à partir de la console Web, appuyez sur le bouton "Connecter" correspondant au cluster que vous souhaitez surveiller.

Une fois que vous avez terminé 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 s'exécutant dans Kubernetes. Lorsque vous exécutez des clusters Kubernetes gérés à l'aide de Google Kubernetes Engine, tous les journaux sont automatiquement transférés et stockés dans Google Cloud Logging. Pour voir toutes les sorties des 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:

Vous pouvez alors exporter les journaux dans Google BigQuery en vue d'une analyse plus approfondie, ou configurer des alertes basées sur les journaux. Nous n'aurons pas l'occasion de le faire dans 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 (qui supprime également les pods en cours d'exécution) et le service (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

Supprimez ensuite 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 Docker Registry qui héberge votre ou 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 entendu, vous pouvez également supprimer l'intégralité du projet, mais vous perdrez l'ensemble de la 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'entraîne l'arrêt de 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.