Esercizio - Configurare l'ambiente

  • 6 minuti

Importante

Per eseguire questo esercizio è necessario disporre di una propria sottoscrizione di Azure e questo potrebbe comportare dei costi. Se non hai ancora una sottoscrizione di Azure, crea un account gratuito prima di iniziare.

Prima di iniziare a lavorare sul flusso di lavoro del sito Web dell'azienda di giocattoli, è necessario configurare l'ambiente. In questa unità ci si assicurerà che gli ambienti Azure e GitHub siano configurati per completare il resto di questo modulo.

Per soddisfare questi obiettivi, è necessario:

  • Configurare un repository GitHub per questo modulo.
  • Clonare il repository del progetto nel computer.
  • Creare due identità del carico di lavoro in Microsoft Entra ID.
  • Creare due gruppi di risorse in Azure.
  • Creare due segreti e ambienti in GitHub.

Ottenere il repository GitHub

In questa sezione ci si assicurerà che il repository GitHub sia configurato per completare il resto del modulo. Per configurarlo, creare un nuovo repository basato su un repository di modelli. Il repository di modelli contiene i file necessari per iniziare con questo modulo.

I moduli di questo percorso di apprendimento sono da seguire in successione. A scopo di apprendimento, ogni modulo ha un repository di modelli GitHub associato.

Suggerimento

Anche se il modulo precedente è stato completato nel percorso di apprendimento, seguire queste istruzioni per creare un nuovo repository e assicurarsi di assegnargli un nuovo nome.

Iniziare dal repository dei modelli

Eseguire un modello che configura il repository GitHub.

Eseguire il modello

Nel sito GitHub seguire questa procedura per creare un repository dal modello:

  1. Selezionare Usa questo modello>Crea un nuovo repository.

    Screenshot dell'interfaccia di GitHub che mostra il repository del modello con il pulsante

  2. Prendere nota del nome dell'organizzazione o del nome utente di GitHub. Nell'esempio il nome utente di GitHub è mygithubuser. Il nome sarà necessario a breve.

  3. Immettere un nome per il nuovo progetto, ad esempio toy-website-environments.

  4. Selezionare l'opzione Public (Pubblico).

    Quando si creano repository personalizzati, è possibile renderli privati. In questo modulo si useranno alcune funzionalità di GitHub che funzionano solo con repository pubblici e con account GitHub Enterprise.

  5. Selezionare Create repository from template (Crea repository da modello).

    Screenshot dell'interfaccia di GitHub che mostra la pagina di creazione del repository.

Importante

L'esercizio finale in questo modulo contiene importanti passaggi di pulizia. Assicurarsi di eseguire la procedura di pulizia anche se non si completa questo modulo.

Clonare il repository

Ora si dispone di una copia del repository di modelli nel proprio account. Poi, clonare questo repository in locale in modo da poter iniziare a usarlo.

  1. Selezionare Codice e selezionare l'icona di copia.

    Screenshot dell'interfaccia di GitHub che mostra il nuovo repository con il pulsante di copia dell'URL del repository evidenziato.

  2. Aprire Visual Studio Code.

  3. Aprire una finestra del terminale di Visual Studio Code selezionando Terminale>Nuovo terminale. La finestra si apre in genere nella parte inferiore della schermata.

  4. Nel terminale passare alla directory nel computer locale, in cui si vuole clonare il repository GitHub. Ad esempio, per clonare il repository nella cartella toy-website-environments, eseguire il comando seguente:

    cd toy-website-environments

  5. Digitare git clone e quindi incollare l'URL copiato in precedenza. Il comando sarà simile al seguente:

    git clone https://github.com/mygithubuser/toy-website-environments.git

  6. Riaprire Visual Studio Code nella cartella del repository eseguendo il comando seguente nel terminale di Visual Studio Code:

    code -r toy-website-environments

Accedere ad Azure

Per usare i gruppi di risorse in Azure, accedere all'account Azure dal terminale di Visual Studio Code. Assicurarsi di avere installato gli strumenti dell'interfaccia della riga di comando di Azure.

  1. Nel menu Terminale selezionare Nuovo terminale. La finestra del terminale si apre solitamente nella parte inferiore della schermata.

    La shell predefinita è in genere pwsh, come illustrato sul lato destro della finestra del terminale.

    Screenshot della finestra del terminale di Visual Studio Code, in cui pwsh viene visualizzato come opzione della shell.

  2. Selezionare l'elenco a discesa Avvia profilo e quindi selezionare Azure Cloud Shell (Bash).

    Screenshot della finestra del terminale di Visual Studio Code. Vengono visualizzati l'elenco a discesa della shell del terminale e la voce di menu Azure Cloud Shell (Bash).

    Verrà aperta una nuova shell.

Accedere ad Azure tramite l'interfaccia della riga di comando di Azure

  1. Nel terminale di Visual Studio Code eseguire il comando seguente per accedere ad Azure:

    az login

  2. Nel browser visualizzato accedere al proprio account Azure.

Per usare i gruppi di risorse in Azure, accedere all'account Azure dal terminale di Visual Studio Code. Assicurarsi di aver installato Azure PowerShell.

  1. Nel menu Terminale selezionare Nuovo terminale. La finestra del terminale si apre solitamente nella parte inferiore della schermata.

    La shell predefinita è in genere pwsh, come illustrato sul lato destro della finestra del terminale.

    Screenshot della finestra del terminale di Visual Studio Code, in cui pwsh viene visualizzato come opzione della shell.

  2. Selezionare l'elenco a discesa Avvia profilo e quindi selezionare Azure Cloud Shell (PowerShell).

    Screenshot della finestra del terminale di Visual Studio Code. Vengono visualizzati l'elenco a discesa della shell del terminale e la voce di menu Azure Cloud Shell (PowerShell).

    Verrà aperta una nuova shell.

Accedere ad Azure usando Azure PowerShell

  1. Nel terminale di Visual Studio Code eseguire il comando seguente per accedere ad Azure:

    Connect-AzAccount

  2. Nel browser visualizzato accedere al proprio account Azure.

Creare due identità dei carichi di lavoro

Creare quindi due identità dei carichi di lavoro in Microsoft Entra ID: una per l'ambiente di test e un'altra per l'ambiente di produzione.

Per creare le identità dei carichi di lavoro, i comandi dell'interfaccia della riga di comando di Azure usano jq per analizzare i dati dall'output JSON. Se jq non è installato, è possibile usare Bash in Azure Cloud Shell per creare l'identità dei carichi di lavoro, il gruppo di risorse e l'assegnazione di ruolo e preparare i segreti di GitHub.

  1. Eseguire il codice seguente per definire variabili per il nome utente e il nome del repository di GitHub. Assicurarsi di sostituire mygithubuser con il nome utente di GitHub, annotato in precedenza in questo esercizio. Assicurarsi inoltre di specificare il nome del repository di GitHub corretto.

    githubOrganizationName='mygithubuser'
githubRepositoryName='toy-website-environments'

  2. Creare un'identità del carico di lavoro per le distribuzioni nell'ambiente di test. L'identità del carico di lavoro richiede due credenziali federate: una viene usata quando il flusso di lavoro esegue il processo validate, perché questo processo non è associato a un ambiente di GitHub. La seconda viene usata quando il flusso di lavoro esegue il processo deploy, che viene eseguito nell'ambiente di Test di GitHub.

    testApplicationRegistrationDetails=$(az ad app create --display-name 'toy-website-environments-test')
testApplicationRegistrationObjectId=$(echo $testApplicationRegistrationDetails | jq -r '.id')
testApplicationRegistrationAppId=$(echo $testApplicationRegistrationDetails | jq -r '.appId')

az ad app federated-credential create \
   --id $testApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-environments-test\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:environment:Test\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

az ad app federated-credential create \
   --id $testApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-environments-test-branch\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:ref:refs/heads/main\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

  3. Eseguire il codice seguente che crea un'identità del carico di lavoro simile e credenziali federate per l'ambiente di produzione:

    productionApplicationRegistrationDetails=$(az ad app create --display-name 'toy-website-environments-production')
productionApplicationRegistrationObjectId=$(echo $productionApplicationRegistrationDetails | jq -r '.id')
productionApplicationRegistrationAppId=$(echo $productionApplicationRegistrationDetails | jq -r '.appId')

az ad app federated-credential create \
   --id $productionApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-environments-production\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:environment:Production\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

az ad app federated-credential create \
   --id $productionApplicationRegistrationObjectId \
   --parameters "{\"name\":\"toy-website-environments-production-branch\",\"issuer\":\"https://token.actions.githubusercontent.com\",\"subject\":\"repo:${githubOrganizationName}/${githubRepositoryName}:ref:refs/heads/main\",\"audiences\":[\"api://AzureADTokenExchange\"]}"

  1. Eseguire il codice seguente per definire variabili per il nome utente e il nome del repository di GitHub. Assicurarsi di sostituire mygithubuser con il nome utente di GitHub, annotato in precedenza in questo esercizio. Assicurarsi inoltre di specificare il nome del repository di GitHub corretto.

    $githubOrganizationName = 'mygithubuser'
$githubRepositoryName = 'toy-website-environments'

  2. Eseguire il codice seguente che crea un'identità del carico di lavoro per l'ambiente di test e la associa al repository di GitHub:

    $testApplicationRegistration = New-AzADApplication -DisplayName 'toy-website-environments-test'
New-AzADAppFederatedCredential `
   -Name 'toy-website-environments-test' `
   -ApplicationObjectId $testApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):environment:Test"
New-AzADAppFederatedCredential `
   -Name 'toy-website-environments-test-branch' `
   -ApplicationObjectId $testApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):ref:refs/heads/main"

  3. Eseguire il codice seguente che segue un processo simile per l'ambiente di produzione:

    $productionApplicationRegistration = New-AzADApplication -DisplayName 'toy-website-environments-production'
New-AzADAppFederatedCredential `
   -Name 'toy-website-environments-production' `
   -ApplicationObjectId $productionApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):environment:Production"
New-AzADAppFederatedCredential `
   -Name 'toy-website-environments-production-branch' `
   -ApplicationObjectId $productionApplicationRegistration.Id `
   -Issuer 'https://token.actions.githubusercontent.com' `
   -Audience 'api://AzureADTokenExchange' `
   -Subject "repo:$($githubOrganizationName)/$($githubRepositoryName):ref:refs/heads/main"

Creare due gruppi di risorse in Azure e concedere l'accesso all'identità del carico di lavoro

Creare quindi un gruppo di risorse per ogni ambiente. Questo processo concede anche alla rispettiva identità del carico di lavoro il ruolo Collaboratore nel gruppo di risorse, che consente la distribuzione del flusso di lavoro nel gruppo di risorse.

  1. Per creare il gruppo di risorse dell'ambiente di test e concedere l'accesso all'identità del carico di lavoro, eseguire i comandi seguenti dell'interfaccia della riga di comando di Azure nel terminale Visual Studio Code:

    testResourceGroupResourceId=$(az group create --name ToyWebsiteTest --location eastus --query id --output tsv)

az ad sp create --id $testApplicationRegistrationObjectId
az role assignment create \
   --assignee $testApplicationRegistrationAppId \
   --role Contributor \
   --scope $testResourceGroupResourceId

  2. Eseguire un processo simile per creare il gruppo di risorse dell'ambiente di produzione:

    productionResourceGroupResourceId=$(az group create --name ToyWebsiteProduction --location eastus --query id --output tsv)

az ad sp create --id $productionApplicationRegistrationObjectId
az role assignment create \
   --assignee $productionApplicationRegistrationAppId \
   --role Contributor \
   --scope $productionResourceGroupResourceId

  1. Per creare il gruppo di risorse dell'ambiente di test e concedere l'accesso all'identità del carico di lavoro, eseguire i comandi seguenti di Azure PowerShell nel terminale di Visual Studio Code:

    $testResourceGroup = New-AzResourceGroup -Name ToyWebsiteTest -Location eastus

New-AzADServicePrincipal -AppId $($testApplicationRegistration.AppId)
New-AzRoleAssignment `
   -ApplicationId $($testApplicationRegistration.AppId) `
   -RoleDefinitionName Contributor `
   -Scope $($testResourceGroup.ResourceId)

  2. Eseguire un processo simile per creare il gruppo di risorse dell'ambiente di produzione:

    $productionResourceGroup = New-AzResourceGroup -Name ToyWebsiteProduction -Location eastus

New-AzADServicePrincipal -AppId $($productionApplicationRegistration.AppId)
New-AzRoleAssignment `
   -ApplicationId $($productionApplicationRegistration.AppId) `
   -RoleDefinitionName Contributor `
   -Scope $($productionResourceGroup.ResourceId)

Preparare i segreti di GitHub

Eseguire il codice seguente per visualizzare i valori che è necessario creare come segreti di GitHub:

echo "AZURE_CLIENT_ID_TEST: $testApplicationRegistrationAppId"
echo "AZURE_CLIENT_ID_PRODUCTION: $productionApplicationRegistrationAppId"
echo "AZURE_TENANT_ID: $(az account show --query tenantId --output tsv)"
echo "AZURE_SUBSCRIPTION_ID: $(az account show --query id --output tsv)"

$azureContext = Get-AzContext
Write-Host "AZURE_CLIENT_ID_TEST: $($testApplicationRegistration.AppId)"
Write-Host "AZURE_CLIENT_ID_PRODUCTION: $($productionApplicationRegistration.AppId)"
Write-Host "AZURE_TENANT_ID: $($azureContext.Tenant.Id)"
Write-Host "AZURE_SUBSCRIPTION_ID: $($azureContext.Subscription.Id)"

Creare segreti di GitHub

Sono state create due identità dei carichi di lavoro e i gruppi di risorse in cui saranno distribuite. Creare ora un segreto in GitHub Actions.

  1. Passare al repository GitHub nel browser.

  2. Selezionare Impostazioni>Segreti e variabili>Azioni.

  3. Selezionare Nuovo segreto repository.

    Screenshot dell'interfaccia di GitHub che mostra la pagina dei segreti, in cui è evidenziato il pulsante per creare un segreto del repository.

  4. Assegnare al segreto il nome AZURE_CLIENT_ID_TEST.

  5. Nel campo Value incollare il GUID dalla prima riga dell'output del terminale. Non includere AZURE_CLIENT_ID_TEST, i due punti o gli spazi nel valore.

  6. Selezionare Aggiungi segreto.

    Screenshot dell'interfaccia GitHub che mostra la pagina del nuovo segreto, con il nome e il valore completati e il pulsante per aggiungere il segreto evidenziato.

  7. Ripetere il processo per creare i segreti per AZURE_CLIENT_ID_PRODUCTION, AZURE_TENANT_ID e AZURE_SUBSCRIPTION_ID, copiando i valori dai campi corrispondenti nell'output del terminale.

  8. Verificare che l'elenco dei segreti mostri ora tutti e quattro i segreti.

    Screenshot dell'interfaccia di GitHub che mostra l'elenco dei segreti, inclusi i segreti di test e di produzione.

Creare ambienti in GitHub

  1. Nel browser passare a Impostazioni>Ambienti.

  2. Selezionare Nuovo ambiente.

    Screenshot dell'interfaccia di GitHub che mostra la pagina Environments e il pulsante per la creazione di un ambiente.

  3. Immettere Test come nome dell'ambiente.

    Screenshot della pagina di GitHub per un nuovo ambiente denominato Test con il pulsante Configure environment.

  4. Selezionare Configura ambiente.

  5. Selezionare Ambienti per tornare all'elenco degli ambienti.

    Screenshot della pagina di GitHub per un nuovo ambiente denominato Test con il collegamento Environment.

  6. Ripetere il processo per creare un altro ambiente denominato Production.

    Lasciare aperta la pagina di configurazione dell'ambiente di produzione.

Aggiungere una regola di protezione all'ambiente di produzione

  1. Selezionare Revisori obbligatori.

  2. Nella casella di testo Cerca persone o team digitare il proprio nome utente GitHub e selezionare se stessi.

    Screenshot dell'interfaccia di GitHub che mostra la pagina per l'aggiunta di un revisore obbligatorio, con dettagli completi e il pulsante Save protection rules.

  3. Selezionare Salva regole di protezione.

  4. Selezionare Ambienti per uscire dalla configurazione.