Esegui il deployment di un'app .NET in Google Kubernetes Engine utilizzando un flusso di lavoro GitHub Actions

Questo tutorial descrive come utilizzare un flusso di lavoro GitHub Actions per eseguire il deployment di un'applicazione web ASP.NET Model-View-Controller (MVC) che utilizza .NET in Google Kubernetes Engine (GKE).

Questo tutorial è destinato a sviluppatori e DevOps engineer che hanno conoscenze di base di Microsoft .NET, GitHub Actions e GKE. Per eseguire questo tutorial è necessario anche un account GitHub.

Obiettivi

Esegui il deployment di un'applicazione web ASP.NET Core che utilizza .NET 6.0 e viene eseguita su Linux in Google Kubernetes Engine.

Il seguente diagramma mostra il flusso di lavoro GitHub Actions per il deployment di un'applicazione web ASP.NET MVC in Google Kubernetes Engine (GKE).

Diagramma concettuale del flusso di lavoro di GitHub Actions

Questo tutorial mostra come completare le seguenti attività per raggiungere il tuo obiettivo:

Creare un repository GitHub
Configura l'autenticazione
Esegui il deployment di un cluster GKE e di un repository Artifact Registry
Crea un flusso di lavoro GitHub Actions

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment dei workload.

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

Creare un repository GitHub

Crea un fork del repository dotnet-docs-samples nel tuo account GitHub. Questo passaggio è necessario perché stiamo eseguendo la build con GitHub Actions.

Vai al repository GitHub di dotnet-docs-samples.
Fai clic su Fork.
Nella pagina Crea un nuovo fork, imposta quanto segue:
- Proprietario: il tuo account GitHub
- Nome repository: dotnet-docs-samples
Fai clic su Crea fork.

Configura l'autenticazione

Prepara il tuo Google Cloud progetto in modo che GitHub Actions possa autenticarsi e accedere alle risorse nel Google Cloud progetto.

Crea un provider e un pool di federazione delle identità del workload

Per consentire a GitHub Actions di autenticarsi Google Cloud e di eseguire il deployment su GKE, utilizza la federazione delle identità per i carichi di lavoro. Utilizzando la federazione delle identità per i workload, puoi evitare la necessità di archiviare e gestire le chiavi dei service account per il tuo workload GitHub Actions.

L'utilizzo della federazione delle identità per i carichi di lavoro richiede un fornitore e un pool di identità del workload. Ti consigliamo di utilizzare un progetto dedicato per gestire i provider e i pool di identità per i carichi di lavoro�. In questo tutorial, per semplicità, crea il pool e il provider nello stesso progetto del cluster GKE:

Apri la console Google Cloud .
Nella console Google Cloud , attiva Cloud Shell.

Attiva Cloud Shell

Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

Crea un nuovo pool di identità del workload:

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

Aggiungi GitHub Actions come fornitore del pool di identità del workload:

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'"

Sostituisci ORGANIZATION con il nome della tua organizzazione GitHub.

Crea un account di servizio

In Cloud Shell, crea un account di servizio che GitHub Actions possa utilizzare per pubblicare immagini Docker ed eseguire il deployment su GKE:

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

Concedi il ruolo di scrittore di Artifact Registry (roles/artifactregistry.writer) all'account di servizio per consentire alle azioni di GitHub di eseguire il push su Artifact Registry:
```
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
  --member serviceAccount:$SERVICE_ACCOUNT \
  --role roles/artifactregistry.writer
```
Concedi il ruolo di sviluppatore Google Kubernetes Engine (roles/container.developer) all'account di servizio per consentire alle azioni di GitHub di eseguire il push su Artifact Registry:
```
gcloud projects add-iam-policy-binding $(gcloud config get-value core/project) \
  --member serviceAccount:$SERVICE_ACCOUNT \
  --role roles/container.developer
```

Consenti al flusso di lavoro GitHub Actions di utilizzare l'account di servizio

Consenti al flusso di lavoro GitHub Actions di rappresentare e utilizzare il account di servizio:

Inizializza una variabile di ambiente che contiene l'oggetto utilizzato dal flusso di lavoro GitHub Actions. Un soggetto è simile a un nome utente che identifica in modo univoco il repository e il ramo GitHub:
```
SUBJECT=repo:OWNER/dotnet-docs-samples:ref:refs/heads/main
```
Sostituisci OWNER con il tuo nome utente GitHub.

Concedi all'utente l'autorizzazione a rappresentare l'account di servizio:

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"

Esegui il deployment di un cluster GKE e di un repository Artifact Registry

Crea un repository per le immagini Docker:

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

Consenti all'account di servizio Compute Engine predefinito di accedere al repository:

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

Crea il cluster:

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

Il completamento di questo comando potrebbe richiedere diversi minuti.

Recupera il nome e il numero del progetto del 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\))"

Ti serviranno in un secondo momento.

Crea un flusso di lavoro GitHub Actions

Ora puoi utilizzare GitHub Actions per configurare l'integrazione continua. Per ogni commit di cui viene eseguito il push nel repository Git, un flusso di lavoro GitHub Actions compila il codice e pacchettizza gli artefatti di build in un container Docker. Il container viene quindi pubblicato in Artifact Registry.

Il repository contiene già il Dockerfile seguente:

#
# 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"]

Il repository contiene anche un manifest 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

Crea un flusso di lavoro GitHub Actions che:

Esegui l'autenticazione a Google Cloud utilizzando la federazione delle identità per i workload e ilaccount di serviziot che hai creato in precedenza.
Crea un'immagine Docker e implementala in Artifact Registry.
Esegui il deployment dell'immagine Docker in GKE.

Per creare il flusso di lavoro GitHub Actions:

Su GitHub, vai al fork del repository dotnet-docs-samples.
Fai clic su Aggiungi file > Crea nuovo file.
Nel campo di testo Assegna un nome al file, inserisci il seguente nome:
```
.github/workflows/deploy-gke.yaml
```

Copia il seguente codice nel file:

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

Sostituisci i seguenti valori:

PROJECT_ID: l'ID progetto del progetto che contiene il cluster GKE.
PROJECT_NUMBER: il numero del progetto che contiene il cluster GKE.

Nella sezione Esegui commit del nuovo file, inserisci un messaggio di commit, ad esempio Add workflow e fai clic su Esegui commit del nuovo file.
Nel menu, fai clic su Azioni e attendi il completamento del flusso di lavoro.

Il completamento del flusso di lavoro potrebbe richiedere diversi minuti.
Nella console Google Cloud , aggiorna la pagina Servizi e Ingress.

Vai a Servizi e Ingress
Vai alla scheda Ingresso.
Individua il servizio in entrata per il cluster clouddemo e attendi che il suo stato passi a Ok. L'operazione potrebbe richiedere alcuni minuti.
Apri il link nella colonna Frontend della stessa riga. Il bilanciatore del carico richiede alcuni minuti per essere disponibile, quindi l'app CloudDemo potrebbe non caricarsi all'inizio. Quando il bilanciatore del carico è pronto, vedrai l'app CloudDemo con il titolo personalizzato, questa volta in esecuzione nel cluster di produzione.

Esegui la pulizia

Al termine del tutorial, puoi eliminare le risorse che hai creato in modo che non utilizzino più la quota generando addebiti. Le sezioni seguenti descrivono come eliminare o disattivare queste risorse.

Elimina il repository GitHub

Per eliminare il repository GitHub, consulta la sezione Eliminare un repository. L'eliminazione del repository comporta la perdita di tutte le modifiche al codice sorgente.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto creato per il tutorial.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per, le attività descritte in questo documento, eliminerai anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Elimina un progetto Google Cloud :

gcloud projects delete PROJECT_ID

Passaggi successivi

Esegui il deployment, gestisci e scala le applicazioni containerizzate su Kubernetes.
Consulta le best practice nel Google Cloud Well-Architected Framework.
Esplora architetture, diagrammi e best practice di riferimento su Google Cloud. Consulta il nostro Cloud Architecture Center.