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

  • 8 minuti

Prima di automatizzare le distribuzioni di siti Web, è necessario distribuire manualmente l'app eShop esistente nel servizio Azure Kubernetes. Crea le risorse di Azure e distribuisci l'app ad AKS utilizzando i comandi di Azure CLI 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.
  • Eseguire il provisioning di un cluster AKS, quindi distribuire i contenitori nel cluster.
  • Testare l'implementazione.
  • 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.

Installazione 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 Spazi di codice .
  3. Selezionare l'icona + per creare lo spazio di codice.

GitHub richiede alcuni minuti per creare e configurare lo spazio di codice. Al termine del processo, viene visualizzato il file di codice per l'esercizio.

Facoltativo: installazione di Visual Studio Code

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

  1. Installare tutti i requisiti di sistema per eseguire Dev Container 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.

Costruire contenitori

  1. Nel riquadro del terminale, eseguire questo comando dotnet CLI:

    dotnet publish /p:PublishProfile=DefaultContainer

Creare le risorse di Azure

  1. Nel riquadro del terminale, accedi ad Azure utilizzando questo comando Azure CLI:

    az login --use-device-code

  2. Visualizzare la sottoscrizione di Azure selezionata.

    az account show -o table

    Se è selezionata la sottoscrizione errata, usare il comando az account set per selezionare quello corretto.

  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 un'area più vicina all'utente 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 la località in un'area di Azure vicina all'utente, 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, assegnarsi come Amministratore dell'automazione della conformità delle app nel controllo di accesso (IAM) del registro dei 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 az acr login --name $ACR_Name viene eseguito, è necessario attivare l'utente amministratore nel registro del contenitore appena creato in Azure in Impostazioni - Chiavi di accesso. Azure chiede di immettere queste credenziali per continuare. Potrebbe anche essere necessario eseguire nuovamente 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. Possono passare alcuni minuti prima di vedere questo output.

      ...
  },
  "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 verificare che il push delle immagini sia stato completato correttamente con questo comando:

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

  7. Crea il tuo AKS e connettilo all'ACR 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 creano un cluster AKS a nodo singolo, lo connettono all'ACR e quindi connettono il computer locale al cluster AKS. Il completamento dei comandi può richiedere alcuni minuti.

  8. Verificare che il nuovo AKS possa pullare le immagini dall'ACR con questo comando:

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

    Verrà visualizzato un output simile ai messaggi seguenti:

    [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 nel nuovo cluster AKS. Copiare l'URL di Registro Azure Container completo dall'output. Ad esempio, l'URL nel codice precedente è acseshop1251599299.

  9. Controlla lo stato del tuo cluster AKS:

    kubectl get nodes -A

    Verrà visualizzato un output simile ai messaggi seguenti:

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

Configurare il file di configurazione 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 EXPLORER di Visual Studio Code o Codespaces selezionare il file deployment.yml nella radice del progetto.

  2. Sostituire alla 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 kubectl comando aggiunge servizi e componenti per consentire l'ingress nel tuo cluster AKS. Verificare che l'ingresso sia pronto per l'esecuzione usando il comando kubernetes seguente:

    kubectl get services --namespace ingress-nginx

    Verrà visualizzato un output simile ai messaggi seguenti:

    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 kubectl apply distribuisce l'app eShop, composta da un'app web front-end Blazor e un servizio di prodotto API REST back-end, insieme a una regola di ingresso per instradare il traffico ai servizi corretti nel tuo cluster AKS. Eseguire di nuovo questo comando se si riceve un errore nelle distribuzioni.

    Verrà visualizzato un output simile ai messaggi seguenti:

    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

    Verrà visualizzato un output simile ai messaggi seguenti:

    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'eShop distribuito con questo comando:

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

    Il comando 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 principale del servizio di Azure AD per 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 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 le informazioni riservate come segreti crittografati in una posizione sicura. GitHub offre una posizione predefinita per archiviare segreti e altre variabili.

Completare i passaggi seguenti 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 lo strumento di esecuzione di GitHub Actions.

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

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

  3. New secret Nella pagina, in Nameimmettere AZURE_CREDENTIALS e in Secretimmettere l'output JSON copiato dal terminale.

    Le impostazioni dovrebbero essere simili allo screenshot seguente:

    Screenshot della nuova pagina segreta per impostare i segreti delle variabili di ambiente in GitHub.

  4. Seleziona Add secret.

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