Distribuire manualmente l'app nativa del cloud nel servizio Azure Kubernetes

  • 8 minuti

Prima di automatizzare le distribuzioni del sito Web, è necessario distribuire manualmente l'app eShop esistente nel servizio Azure Kubernetes. Si creano le risorse di Azure e si distribuisce l'app nel servizio Azure Kubernetes usando i comandi dell'interfaccia della riga di comando di Azure e gli script bash. Infine, si crea un'entità servizio di Azure Active Directory (Azure AD) per consentire a GitHub Actions di eseguire la distribuzione nel servizio Azure Kubernetes e nel Registro Azure Container.

I comandi creano le risorse seguenti per distribuire una versione aggiornata dell'app eShop.

  • Effettuare il provisioning di un Registro Azure Container e quindi eseguire il push delle immagini nel registro.
  • Effettuare il provisioning di un cluster del servizio Azure Kubernetes e quindi distribuire i contenitori nel cluster.
  • Testare la distribuzione.
  • Creare entità servizio per consentire a GitHub Actions di eseguire la distribuzione nel servizio Azure Kubernetes e nel Registro Azure Container.

Importante

Assicurarsi di aver completato i prerequisiti prima di iniziare.

Aprire l'ambiente di sviluppo

Si può scegliere di ospitare l'esercizio in un codespace GitHub oppure di completarlo in locale in Visual Studio Code.

Configurazione di GitHub Codespaces

Creare una copia tramite fork del repository https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops nel proprio account GitHub. Quindi nel nuovo fork:

  1. Selezionare Codice.
  2. Selezionare la scheda Codespaces.
  3. Selezionare l'icona + per creare il codespace.

GitHub impiega qualche minuto per creare e configurare il codespace. Al termine del processo, vengono visualizzati i file di codice per l'esercizio.

Facoltativo: Configurazione di Visual Studio Code

Per usare Visual Studio Code, creare tramite fork una copia del repository https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative-devops nel proprio account GitHub e clonarlo in locale. Quindi:

  1. Installare eventuali requisiti di sistema per eseguire il contenitore di sviluppo in Visual Studio Code.
  2. Verificare che Docker sia in esecuzione.
  3. In una nuova finestra di Visual Studio Code aprire la cartella del repository clonato
  4. Premere CTRL+MAIUSC+P per aprire il riquadro comandi.
  5. Ricerca: >Contenitori di sviluppo: Ricompilare e riaprire nel contenitore
  6. Visual Studio Code crea il contenitore di sviluppo in locale.

Creare i contenitori

  1. Nel riquadro del terminale eseguire questo comando dell'interfaccia della riga di comando dotnet:

    dotnet publish /p:PublishProfile=DefaultContainer

Creare le risorse di Azure

  1. Nel riquadro del terminale accedere ad Azure con questo comando dell'interfaccia della riga di comando di Azure:

    az login --use-device-code

  2. Visualizzare la sottoscrizione di Azure selezionata.

    az account show -o table

    Se è selezionata la sottoscrizione errata, selezionare quella corretta usando il comando az account set.

  3. Eseguire il comando seguente dell'interfaccia della riga di comando di Azure per ottenere un elenco di aree di Azure e il nome associato:

    az account list-locations -o table

    Individuare l'area più vicina e usarla nel passaggio successivo sostituendo [Closest Azure region]

  4. Eseguire queste istruzioni bash:

    export LOCATION=[Closest Azure region]
export RESOURCE_GROUP=rg-eshop
export CLUSTER_NAME=aks-eshop
export ACR_NAME=acseshop$SRANDOM

    I comandi precedenti creano variabili di ambiente che verranno usate nei comandi successivi dell'interfaccia della riga di comando di Azure. È necessario modificare il valore di LOCATION specificando un'area di Azure vicina, ad esempio, eastus. Se si vuole usare un nome diverso per il gruppo di risorse, il cluster del servizio Azure Kubernetes o Registro Azure Container, modificare tali valori. Per visualizzare i nuovi repository nel portale di Azure, assegnare se stessi come amministratore di automazione della conformità delle app nel controllo di accesso (IAM) del registro contenitori.

  5. Eseguire questi comandi dell'interfaccia della riga di comando di Azure:

    az group create --name $RESOURCE_GROUP --location $LOCATION
az acr create --resource-group $RESOURCE_GROUP --name $ACR_NAME --sku Basic
az acr login --name $ACR_NAME

    Se viene visualizzato un errore di autenticazione quando si esegue az acr login --name $ACR_Name, è necessario attivare Utente amministratore nel registro contenitori appena creato in Azure in Impostazioni - Chiavi di accesso. Azure chiede di immettere queste credenziali per continuare. Potrebbe anche essere necessario eseguire di nuovo l'autenticazione con az login --use-device-code.

    Questi comandi creano un gruppo di risorse per contenere le risorse di Azure, un Registro Azure Container per le immagini e quindi un account di accesso per il Registro Azure Container. Per visualizzare questo output possono essere richiesti alcuni minuti:

      ...
  },
  "status": null,
  "systemData": {
    "createdAt": "2023-10-19T09:11:51.389157+00:00",
    "createdBy": "",
    "createdByType": "User",
    "lastModifiedAt": "2023-10-19T09:11:51.389157+00:00",
    "lastModifiedBy": "",
    "lastModifiedByType": "User"
  },
  "tags": {},
  "type": "Microsoft.ContainerRegistry/registries",
  "zoneRedundancy": "Disabled"
}
Login Succeeded

  6. Per contrassegnare le immagini ed eseguirne il push nel Registro Azure Container creato, eseguire questi comandi:

    docker tag store $ACR_NAME.azurecr.io/storeimage:v1
docker tag products $ACR_NAME.azurecr.io/productservice:v1

docker push $ACR_NAME.azurecr.io/storeimage:v1
docker push $ACR_NAME.azurecr.io/productservice:v1

    È possibile controllare che il push delle immagini venga completato correttamente con questo comando:

    az acr repository list --name $ACR_NAME --output table

  7. Creare il servizio Azure Kubernetes e connetterlo al Registro Azure Container con questi comandi:

    az aks create --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --node-count 1 --generate-ssh-keys --node-vm-size Standard_B2s --network-plugin azure --attach-acr $ACR_NAME

az aks get-credentials --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

    I comandi precedenti creano un cluster del servizio Azure Kubernetes a nodo singolo, lo connettono al Registro Azure Container e quindi connettono il computer locale al cluster del servizio Azure Kubernetes. Il completamento dei comandi precedenti può richiedere alcuni minuti.

  8. Verificare che il nuovo servizio Azure Kubernetes possa eseguire il pull delle immagini dal Registro Azure Container con questo comando:

    az aks check-acr --acr $ACR_NAME.azurecr.io --name $CLUSTER_NAME --resource-group $RESOURCE_GROUP

    L'output sarà simile al seguente con questi messaggi:

    [2023-10-19T13:33:09Z] Loading azure.json file from /etc/kubernetes/azure.json
[2023-10-19T13:33:09Z] Checking managed identity...
[2023-10-19T13:33:09Z] Cluster cloud name: AzurePublicCloud
[2023-10-19T13:33:09Z] Kubelet managed identity client ID: 00001111-aaaa-2222-bbbb-3333cccc4444
[2023-10-19T13:33:09Z] Validating managed identity existance: SUCCEEDED
[2023-10-19T13:33:09Z] Validating image pull permission: SUCCEEDED
[2023-10-19T13:33:09Z] 
Your cluster can pull images from acseshop1251599299.azurecr.io!

    È ora possibile eseguire comandi kubectl sul nuovo cluster del servizio Azure Kubernetes. Copiare l'URL di Registro Azure Container completo dall'output. Ad esempio, l'URL nel codice precedente è acseshop1251599299.

  9. Controllare lo stato del cluster del servizio Azure Kubernetes:

    kubectl get nodes -A

    L'output sarà simile al seguente con questi messaggi:

    NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-37200563-vmss000000   Ready    agent   3h44m   v1.26.6

Configurare il manifesto della distribuzione Kubernetes

Ora che le immagini di eShop si trovano nel Registro Azure Container, è possibile aggiornare il manifesto della distribuzione del servizio Azure Kubernetes per usare queste nuove immagini.

  1. Nel pannello ESPLORA RISORSE di Visual Studio Code selezionare il file deployment.yml nella radice del progetto.

  2. Sostituire nella riga 17:

    - image: [replace with your ACR name].azurecr.io/storeimage:v1

    Incollare il nome del Registro Azure Container copiato dal passaggio precedente. La riga dovrebbe essere simile al codice yaml seguente:

    - image: acseshop1251599299.azurecr.io/storeimage:v1

  3. Ripetere questi passaggi per la riga 65:

    - image: [replace with your ACR name].azurecr.io/productservice:v1

    Salvare il file con CTRL+S.

  4. Nel riquadro del terminale distribuire un controller di ingresso NGINX con il comando kubernetes seguente:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.9.3/deploy/static/provider/cloud/deploy.yaml

    Il comando kubectl precedente aggiunge servizi e componenti per consentire l'ingresso nel cluster del servizio Azure Kubernetes. Verificare che l'ingresso sia pronto per l'esecuzione usando il comando kubernetes seguente:

    kubectl get services --namespace ingress-nginx

    L'output sarà simile al seguente con questi messaggi:

    NAME                                 TYPE           CLUSTER-IP     EXTERNAL-IP    PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.0.135.51    20.26.154.64   80:32115/TCP,443:32254/TCP   58s
ingress-nginx-controller-admission   ClusterIP      10.0.137.137   <none>         443/TCP                      58s

  5. Distribuire l'app eShop con questo comando:

    kubectl apply -f deployment.yml

    Il comando apply kubectl distribuisce l'app eShop, un'app Web Blazor front-end e un servizio dei prodotti API REST back-end e una regola di ingresso per instradare il traffico ai servizi corretti nel cluster del servizio Azure Kubernetes. Eseguire di nuovo questo comando in caso di errori per le distribuzioni.

    L'output sarà simile al seguente con questi messaggi:

    deployment.apps/storeimage created
service/eshop-website created
deployment.apps/productservice created
service/eshop-backend created
ingress.networking.k8s.io/eshop-ingress created

  6. Verificare che i due microservizi siano distribuiti con questo comando:

    kubectl get pods -A

    L'output sarà simile al seguente con questi messaggi:

    NAMESPACE       NAME                                        READY   STATUS      RESTARTS   AGE
default         productservice-7569b8c64-vfbfz              1/1     Running     0          3m56s
default         storeimage-6c7c999d7c-zsnxd                 1/1     Running     0          3m56s
ingress-nginx   ingress-nginx-admission-create-szb8l        0/1     Completed   0          4m4s
ingress-nginx   ingress-nginx-admission-patch-czdbv         0/1     Completed   0          4m4s
ingress-nginx   ingress-nginx-controller-58bf5bf7dc-nwtsr   1/1     Running     0          4m4s

  7. Visualizzare l'app eShop distribuita con questo comando:

    echo "http://$(kubectl get services --namespace ingress-nginx ingress-nginx-controller --output jsonpath='{.status.loadBalancer.ingress[0].ip}')"

    Il comando precedente restituisce l'indirizzo IP esterno per l'app Web. Tenere premuto CTRL e fare clic sul collegamento per aprire l'app in una nuova scheda.

    Screenshot della home page dell'app Web eShop.

Creare un'entità servizio per la distribuzione da GitHub

GitHub Actions può pubblicare immagini del contenitore in un Registro Azure Container. Lo strumento di esecuzione di GitHub deve quindi avere le autorizzazioni per connettersi ad Azure. La procedura seguente consente di creare un'entità servizio di Azure AD per agire come identità di GitHub Actions in Azure.

  1. Per salvare l'ID sottoscrizione in una variabile di ambiente, eseguire il comando seguente nel terminale:

    export SUBS=$(az account show --query 'id' --output tsv)

  2. Per creare un'entità servizio di Azure Active Directory al fine di consentire l'accesso da GitHub, eseguire il comando seguente:

    az ad sp create-for-rbac --name "eShop" --role contributor --scopes /subscriptions/$SUBS/resourceGroups/$RESOURCE_GROUP --json-auth

    Compare una variante dell'output seguente:

    Creating 'Contributor' role assignment under scope '/subscriptions/ffffffff-aaaa-bbbb-6666-777777777777'

The output includes credentials that you must protect. Be sure that you do not include these credentials in your code or check the credentials into your source control. For more information, see https://aka.ms/azadsp-cli
 {
  "clientId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "clientSecret": "abc1A~abc123ABC123abc123ABC123abc123ABC1",
  "subscriptionId": "00000000-0000-0000-0000-000000000000",
  "tenantId": "00000000-0000-0000-0000-000000000000",
  "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
  "resourceManagerEndpointUrl": "https://management.azure.com/",
  "activeDirectoryGraphResourceId": "https://graph.windows.net/",
  "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
  "galleryEndpointUrl": "https://gallery.azure.com/",
  "managementEndpointUrl": "https://management.core.windows.net/"
}

  3. Copiare l'output JSON e le parentesi quadre da usare nel passaggio successivo.

Creare i segreti di GitHub

Lo strumento di esecuzione di GitHub Actions richiede che le credenziali interagiscano con il registro Azure Container e il servizio Azure Kubernetes. L'entità servizio e le credenziali per il registro contenitori sono informazioni riservate. È consigliabile archiviare informazioni riservate come segreti crittografati in una posizione sicura. GitHub offre una posizione predefinita per archiviare segreti e altre variabili.

Completare la seguente procedura per archiviare in modo sicuro le informazioni riservate come variabili di ambiente nel repository. Gli amministratori del repository devono gestire i segreti a cui può accedere il GitHub Actions runner.

  1. Nel repository GitHub forked passare a Settings>Secrets and variables>Actions.

  2. Nella pagina Actions secrets and variables, selezionare New repository secret.

  3. Nella paginaNew secret, in Name immettere AZURE_CREDENTIALS e in Secret, immettere l'output JSON copiato dal terminale.

    Il risultato finale dovrebbe essere simile a quello riportato nella schermata seguente.

    Screenshot della nuova pagina segreta per impostare i segreti variabili ambientali di GitHub.

  4. Selezionare Add secret.

Questo segreto di GitHub verrà usato nella sezione successiva per creare un'azione GitHub per compilare l'immagine del contenitore.