Déployer une application .NET sur Google Kubernetes Engine à l'aide d'un workflow GitHub Actions

Ce tutoriel explique comment utiliser un workflow GitHub Actions pour déployer une application Web ASP.NET Model-View-Controller (MVC) qui utilise .NET sur Google Kubernetes Engine (GKE).

Ce tutoriel est destiné aux développeurs et aux ingénieurs DevOps qui possèdent des connaissances de base sur Microsoft .NET, GitHub Actions et GKE. Vous devez également disposer d'un compte GitHub pour suivre ce tutoriel.

Objectifs

Déployez une application Web ASP.NET Core qui utilise .NET 6.0 et s'exécute sous Linux sur Google Kubernetes Engine.

Le schéma suivant illustre le workflow GitHub Actions permettant de déployer une application Web ASP.NET MVC sur Google Kubernetes Engine (GKE).

Diagramme conceptuel du workflow GitHub Actions

Ce tutoriel vous explique comment effectuer les tâches suivantes, en vue d'atteindre votre objectif :

Créer un dépôt GitHub
Configurer l'authentification
Déployer un cluster GKE et un dépôt Artifact Registry
Créer un workflow GitHub Actions

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Pour obtenir une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Une fois que vous avez terminé les tâches décrites dans ce document, supprimez les ressources que vous avez créées pour éviter que des frais vous soient facturés. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry and Google Kubernetes Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Artifact Registry and Google Kubernetes Engine APIs.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Créer un dépôt GitHub

Créez un fork du dépôt dotnet-docs-samples dans votre compte GitHub. Cette étape est nécessaire, car nous effectuons la compilation avec GitHub Actions.

Accédez au dépôt GitHub dotnet-docs-samples.
Cliquez sur Dupliquer.
Sur la page Créer un fork, définissez les éléments suivants :
- Propriétaire : votre compte GitHub
- Nom du dépôt : dotnet-docs-samples
Cliquez sur Créer un fork.

Configurer l'authentification

Préparez votre projet Google Cloud pour que GitHub Actions puisse s'authentifier et accéder aux ressources du projet Google Cloud .

Créer un pool et un fournisseur de fédération d'identité de charge de travail

Pour permettre à GitHub Actions de s'authentifier Google Cloud et de déployer sur GKE, utilisez la fédération d'identité de charge de travail. L'utilisation de la fédération d'identité de charge de travail vous évite d'avoir à stocker et gérer des clés de compte de service pour votre charge de travail GitHub Actions.

L'utilisation de la fédération d'identité de charge de travail nécessite un pool et un fournisseur d'identités de charge de travail. Nous vous recommandons d'utiliser un projet dédié pour gérer les pools et les fournisseurs d'identités de charge de travail. Dans ce tutoriel, pour plus de simplicité, créez le pool et le fournisseur dans le même projet que votre cluster GKE :

Ouvrez la console Google Cloud .
Dans la console Google Cloud , activez Cloud Shell.

Activer Cloud Shell

En bas de la console Google Cloud , une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel Google Cloud CLI est déjà installé, et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.

Créez un pool d'identités de charge de travail :

gcloud iam workload-identity-pools create github-actions \
    --location="global" \
    --description="GitHub Actions tutorial" \
    --display-name="GitHub Actions"

Ajoutez GitHub Actions en tant que fournisseur de pools d'identités de charge de travail :

gcloud iam workload-identity-pools providers create-oidc github-actions-oidc \
    --location="global" \
    --workload-identity-pool=github-actions \
    --issuer-uri="https://token.actions.githubusercontent.com/" \
    --attribute-mapping="google.subject=assertion.sub" \
    --attribute-condition="assertion.repository_owner=='ORGANIZATION'"

Remplacez ORGANIZATION par le nom de votre organisation GitHub.

Créer un compte de service

Dans Cloud Shell, créez un compte de service que GitHub Actions peut utiliser pour publier des images Docker et les déployer sur GKE :

SERVICE_ACCOUNT=$(gcloud iam service-accounts create github-actions-workflow \
  --display-name "GitHub Actions workflow" \
  --format "value(email)")

Attribuez le rôle de rédacteur Artifact Registry (roles/artifactregistry.writer) au compte de service pour permettre à GitHub Actions d'envoyer des éléments à Artifact Registry :
```
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
  --member serviceAccount:$SERVICE_ACCOUNT \
  --role roles/artifactregistry.writer
```
Accordez le rôle Développeur Google Kubernetes Engine (roles/container.developer) au compte de service pour permettre aux actions GitHub d'envoyer des éléments à Artifact Registry :
```
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
  --member serviceAccount:$SERVICE_ACCOUNT \
  --role roles/container.developer
```

Autoriser le workflow GitHub Actions à utiliser le compte de service

Autorisez le workflow GitHub Actions à emprunter l'identité du compte de service et à l'utiliser :

Initialisez une variable d'environnement contenant le sujet utilisé par le workflow GitHub Actions. Un sujet est semblable à un nom d'utilisateur qui identifie de manière unique le dépôt et la branche GitHub :
```
SUBJECT=repo:OWNER/dotnet-docs-samples:ref:refs/heads/main
```
Remplacez OWNER par votre nom d'utilisateur GitHub.

Accordez à l'utilisateur l'autorisation d'emprunter l'identité du compte de service :

PROJECT_NUMBER=$(gcloud projects describe $(gcloud config get-value core/project) --format='value(projectNumber)')

gcloud iam service-accounts add-iam-policy-binding $SERVICE_ACCOUNT \
  --role=roles/iam.workloadIdentityUser \
  --member="principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/github-actions/subject/$SUBJECT"

Déployer un cluster GKE et un dépôt Artifact Registry

Créez un dépôt pour les images Docker :

gcloud artifacts repositories create clouddemo \
  --repository-format=docker \
  --location=us-central1

Autorisez le compte de service Compute Engine par défaut à accéder au dépôt :

gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
  --member=serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
  --role=roles/artifactregistry.reader

Créez le cluster :

gcloud container clusters create clouddemo-linux \
  --enable-ip-alias \
  --zone us-central1-a

Cette commande peut prendre plusieurs minutes.

Obtenez le nom et le numéro du projet du cluster :

echo "Project ID: $(gcloud config get-value core/project)"
echo "Project Number: $(gcloud projects describe $(gcloud config get-value core/project) --format=value\(projectNumber\))"

Vous aurez besoin de ces valeurs ultérieurement.

Créer un workflow GitHub Actions

Vous pouvez maintenant utiliser GitHub Actions pour configurer une intégration continue. Pour chaque commit envoyé dans le dépôt Git, un workflow GitHub Actions compile le code et crée un package des artefacts de la compilation dans un conteneur Docker. Le conteneur est ensuite publié dans Artifact Registry.

Le dépôt contient déjà le fichier Dockerfile suivant :

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

FROM mcr.microsoft.com/dotnet/aspnet:6.0
EXPOSE 8080

#------------------------------------------------------------------------------
# Copy publishing artifacts.
#------------------------------------------------------------------------------

WORKDIR /app
COPY CloudDemo.MvcCore/bin/Release/net6.0/publish/ /app/

ENV ASPNETCORE_URLS=http://0.0.0.0:8080

#------------------------------------------------------------------------------
# Run application in Kestrel.
#------------------------------------------------------------------------------

ENTRYPOINT ["dotnet", "CloudDemo.MvcCore.dll"]

Le dépôt contient également un fichier manifeste Kubernetes :

#
# Copyright 2020 Google LLC
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
# 
#   http://www.apache.org/licenses/LICENSE-2.0
# 
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

apiVersion: v1
kind: Service
metadata:
  name: clouddemo-netcore
spec:
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP
    name: http
  selector:
    app: clouddemo-netcore
  type: NodePort

---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: clouddemo-netcore
spec:
  defaultBackend:
    service:
      name: clouddemo-netcore
      port:
        number: 80

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: clouddemo-netcore
spec:
  replicas: 2
  selector:
    matchLabels:
      app: clouddemo-netcore
  template:
    metadata:
      labels:
        app: clouddemo-netcore
    spec:
      containers:
      - name: clouddemo-netcore
        image: CLOUDDEMO_IMAGE
        ports:
          - containerPort: 8080
        livenessProbe:      # Used by deployment controller
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5
        readinessProbe:     # Used by Ingress/GCLB
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 3
          periodSeconds: 5
        resources:
          limits:
            memory: 1024Mi
          requests:
            memory: 256Mi

Créez un workflow GitHub Actions qui effectue les opérations suivantes :

Authentifiez-vous auprès de Google Cloud à l'aide de la fédération d'identité de charge de travail et du compte de service que vous avez créé précédemment.
Créez une image Docker et déployez-la dans Artifact Registry.
Déployez l'image Docker sur GKE.

Pour créer le workflow GitHub Actions, procédez comme suit :

Sur GitHub, accédez à votre copie du dépôt dotnet-docs-samples.
Cliquez sur Ajouter un fichier > Créer un fichier.
Dans le champ de texte Attribuer un nom au fichier, saisissez le nom suivant :
```
.github/workflows/deploy-gke.yaml
```

Copiez le code suivant dans le fichier :

name: Build and Deploy to GKE

on:
  push:
    branches:
      - main

env:
  PROJECT_ID: PROJECT_ID
  PROJECT_NUMBER: PROJECT_NUMBER

  CLUSTER: clouddemo-linux
  CLUSTER_ZONE: us-central1-a

  REPOSITORY: clouddemo
  REPOSITORY_REGION: us-central1

  IMAGE: clouddemo

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read

    steps:
    - name: Checkout
      uses: actions/checkout@v3

    #
    # Authenticate to Google Cloud using workload identity federation
    #
    - id: 'auth'
      name: 'Obtain access token by using workload identity federation'
      uses: 'google-github-actions/auth@v0'
      with:
        create_credentials_file: true
        token_format: access_token
        workload_identity_provider: projects/${{ env.PROJECT_NUMBER }}/locations/global/workloadIdentityPools/github-actions/providers/github-actions-oidc
        service_account: github-actions-workflow@${{ env.PROJECT_ID }}.iam.gserviceaccount.com

    - name: Connect to Artifact Registry
      run: |-
        echo ${{ steps.auth.outputs.access_token }} | docker login -u oauth2accesstoken --password-stdin https://${{ env.REPOSITORY_REGION }}-docker.pkg.dev

    - name: Connect to GKE
      uses: google-github-actions/get-gke-credentials@v0
      with:
        cluster_name: ${{ env.CLUSTER }}
        location: ${{ env.CLUSTER_ZONE }}

    #
    # Build the .NET code
    #
    - name: Build solution
      run: |-
        dotnet publish applications/clouddemo/netcore/CloudDemo.MvcCore.sln \
            --configuration Release \
            --framework net6.0

    #
    # Build the Docker image and push it to Artifact Registry
    #
    - name: Create image tag
      run: echo "IMAGE_TAG=${{ env.REPOSITORY_REGION }}-docker.pkg.dev/${{ env.PROJECT_ID }}/${{ env.REPOSITORY }}/${{ env.IMAGE }}:$GITHUB_SHA" >> $GITHUB_ENV

    - name: Lock image version in deployment.yaml
      run: sed -i 's|CLOUDDEMO_IMAGE|${{ env.IMAGE_TAG }}|g' applications/clouddemo/netcore/deployment.yaml

    - name: Build Docker image
      run: docker build --tag "${{ env.IMAGE_TAG }}" applications/clouddemo/netcore

    - name: Publish Docker image to Google Artifact Registry
      run: docker push "${{ env.IMAGE_TAG }}"

    #
    # Deploy to GKE
    #
    - name: Deploy to GKE
      run: kubectl apply -f applications/clouddemo/netcore/deployment.yaml

Remplacez les valeurs suivantes :

PROJECT_ID : ID du projet contenant le cluster GKE.
PROJECT_NUMBER : numéro du projet contenant le cluster GKE.

Dans la section Effectuer un commit du nouveau fichier, saisissez un message de commit, par exemple Add workflow, puis cliquez sur Effectuer un commit du nouveau fichier.
Dans le menu, cliquez sur Actions et attendez la fin du workflow.

L'exécution du workflow peut prendre plusieurs minutes.
Dans la console Google Cloud , actualisez la page Services et entrées.

Accéder à la page Services et entrées
Accédez à l'onglet Ingress.
Recherchez le service d'Ingress pour le cluster clouddemo et attendez que son état bascule sur OK. Cela peut prendre quelques minutes.
Ouvrez le lien dans la colonne Interfaces de la même ligne. L'équilibreur de charge met quelques minutes à être disponible. Il est donc possible que l'application CloudDemo ne se charge pas au début. Lorsque l'équilibreur de charge est prêt, l'application CloudDemo s'affiche avec le titre personnalisé, qui s'exécute cette fois-ci dans le cluster de production.

Effectuer un nettoyage

Une fois le tutoriel terminé, vous pouvez procéder au nettoyage des ressources que vous avez créées afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le dépôt GitHub

Pour supprimer le dépôt GitHub, consultez Supprimer un dépôt. La suppression du dépôt entraîne la perte de toutes les modifications du code source.

Supprimer le projet

Le moyen le plus simple d’éliminer la facturation consiste à supprimer le projet que vous avez créé pour ce tutoriel.

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Supprimer un projet Google Cloud :

gcloud projects delete PROJECT_ID

Étapes suivantes

Déployez, gérez et faites évoluer des applications conteneurisées sur Kubernetes.
Consultez les bonnes pratiques dans le Google Cloud Framework Well-Architected.
Découvrez des architectures de référence, des schémas et des bonnes pratiques concernant Google Cloud. Consultez notre Cloud Architecture Center.