Esercitazione: Integrazione continua dei modelli di Resource Manager con Azure Pipelines

Articolo
09/26/2024

Nell'esercitazione precedente è stato distribuito un modello collegato. In questa esercitazione viene spiegato come usare Azure Pipelines per creare e distribuire progetti di modelli di Azure Resource Manager (modello di ARM) in modo continuo.

Azure DevOps fornisce servizi di sviluppo a team di supporto per pianificare il lavoro, collaborare allo sviluppo di codice e creare e distribuire applicazioni. Gli sviluppatori possono lavorare nel cloud usando Azure DevOps Services. Azure DevOps fornisce un set integrato di funzionalità a cui è possibile accedere tramite il Web browser o il client IDE. Azure Pipelines è una di queste funzionalità. Si tratta di un servizio completo per l'integrazione continua e il recapito continuo, in grado di funzionare con il provider Git preferito dall'utente e di eseguire la distribuzione ai servizi cloud più importanti. È quindi possibile automatizzare la compilazione, il testing e la distribuzione del codice a Microsoft Azure, Google Cloud Platform o Amazon Web Services.

Nota

Scegliere un nome per il progetto. Quando si esegue l'esercitazione, sostituire uno qualsiasi di ARMPipelineProj con il nome del progetto. Questo nome del progetto viene usato per generare i nomi delle risorse. Una delle risorse è un account di archiviazione. I nomi degli account di archiviazione devono essere di lunghezza compresa tra 3 e 24 caratteri e utilizzare solo numeri e lettere minuscole. Il nome deve essere univoco. Nel modello il nome dell'account di archiviazione è il nome del progetto con l'aggiunta di store e il nome del progetto deve avere una lunghezza compresa tra 3 e 11 caratteri. Quindi il nome del progetto deve soddisfare i requisiti del nome dell'account di archiviazione e deve avere meno di 11 caratteri.

Questa esercitazione illustra le attività seguenti:

Preparare un repository GitHub
Creare un progetto Azure DevOps
Creare una pipeline di Azure
Verificare la distribuzione della pipeline
Aggiornare il modello e ridistribuirlo
Pulire le risorse

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Prerequisiti

Per completare questo articolo, devi avere quanto segue:

Un account GitHub da usare per creare un repository per i modelli. Se non hai un account, puoi crearlo gratuitamente. Per altre informazioni sull'uso dei repository GitHub, vedere Creare repository GitHub.
Installare Git. In questa esercitazione viene usato Git Bash o Git Shell. Per le istruzioni, vedere Install Git (Installare Git).
Un'organizzazione Azure DevOps. Se non hai un account, puoi crearlo gratuitamente. Vedere Creare un'organizzazione o una raccolta di progetti.
(facoltativo) Visual Studio Code con l'estensione Strumenti di Resource Manager. Vedere Avvio rapido: Creare modelli di Resource Manager con Visual Studio Code.

Preparare un repository GitHub

GitHub consente di archiviare il codice sorgente del progetto, inclusi i modelli di Resource Manager. Per altri repository supportati, vedere la sezione relativa ai repository supportati da Azure DevOps.

Creare un repository GitHub

Se non si dispone di un account GitHub, vedere Prerequisiti.

Accedi a GitHub.
Selezionare l'immagine del proprio account nell'angolo in alto a destra e quindi scegliere Your repositories (Repository personali).
Fare clic su New (Nuovo), un pulsante di colore verde.
In Repository name (Nome repository) immettere un nome per il repository. Ad esempio, ARMPipeline-repo. Ricordarsi di sostituire uno qualsiasi armPipeline con il nome del progetto. È possibile selezionare Public (Pubblico) o Private (Privato) per procedere in questa esercitazione e quindi fare clic su Create repository (Crea repository).
Prendere nota dell'URL. Il formato dell'URL del repository è il seguente: https://github.com/[YourAccountName]/[YourRepositoryName].

Questo repository viene indicato come repository remoto. Ogni sviluppatore dello stesso progetto può clonare il rispettivo repository locale e unire le modifiche nel repository remoto.

Clonare il repository remoto

Aprire Git Shell o Git Bash. Vedere Prerequisiti.
Verificare che la cartella corrente sia GitHub.
Esegui questo comando:
```
git clone https://github.com/[YourAccountName]/[YourGitHubRepositoryName]
cd [YourGitHubRepositoryName]
mkdir create_web_app
cd create_web_app
pwd
```
Sostituire [YourAccountName] con il nome dell'account GitHub e sostituire [YourGitHubRepositoryName] con il nome del repository creato nella procedura precedente.

La cartella create_web_app è la cartella in cui è archiviato il modello. Il pwd comando mostra il percorso della cartella. Il percorso è la posizione in cui verrà salvato il modello nella procedura seguente.

Scaricare un modello di avvio rapido

Anziché creare i modelli, è possibile scaricare i modelli e salvarli nella cartella create_web_app .

Sia il nome della cartella sia i nomi file vengono usati così come sono nella pipeline. Se si modificano questi nomi, sarà necessario aggiornare i nomi usati nella pipeline.

Eseguire il push del modello nel repository remoto

Il file azuredeploy.json è stato aggiunto al repository locale. È quindi necessario caricare il modello nel repository remoto.

Aprire Git Shell o Git Bash, se non è aperto.
Passare alla cartella create_web_app nel repository locale.
Verificare che il file azuredeploy.json si trovi in tale cartella.
Esegui questo comando:
```
git add .
git commit -m "Add web app templates."
git push origin main
```
È possibile che venga visualizzato un avviso relativo all'avanzamento riga. Tale avviso può essere ignorato. main è il ramo principale. In genere si crea un ramo per ogni aggiornamento. Per semplificare l'esercitazione, viene usato direttamente il ramo principale.
Accedere al repository GitHub da un browser. L'URL è https://github.com/[YourAccountName]/[YourGitHubRepository]. Verrà visualizzata la cartella create_web_app e i due file all'interno della cartella.
Selezionare azuredeploy.json per aprire il modello.
Selezionare il pulsante Non elaborato. L'URL inizia con https://raw.githubusercontent.com.
Copiare l'URL. È necessario fornire questo valore quando si configura la pipeline più avanti nell'esercitazione.

Fino a questo punto è stato creato un repository GitHub e sono stati caricati i modelli nel repository.

Creare un progetto DevOps

Prima di poter passare alla procedura che segue, è necessario avere un'organizzazione DevOps. Se non si dispone di una tale organizzazione, vedere Prerequisiti.

Accedere a Azure DevOps.
Selezionare un'organizzazione DevOps a sinistra e quindi selezionare Nuovo progetto. Se non si dispone di progetti, verrà visualizzata automaticamente la pagina per la creazione di un progetto.
Immettere i valori seguenti:
- Nome progetto: immettere un nome di progetto. È possibile usare il nome di progetto scelto all'inizio dell'esercitazione.
- Visibilità: selezionare Privato.
Usare il valore predefinito per le altre proprietà.
Seleziona Crea.

Creare una connessione al servizio da usare per distribuire i progetti ad Azure.

Scegliere Project settings (Impostazioni progetto) dalla parte inferiore del menu di sinistra.
In Pipelines (Pipeline) selezionare Service connections (Connessioni al servizio).
Selezionare Crea connessione al servizio, selezionare Azure Resource Manager e quindi avanti.
Selezionare Entità servizio e quindi selezionare Avanti.
Immettere i valori seguenti:
- Scope level (Livello ambito): selezionare Subscription (Sottoscrizione).
- Sottoscrizione: selezionare la propria sottoscrizione.
- Gruppo di risorse: lasciare vuoto.
- Connection name (Nome connessione): immettere un nome per la connessione. Ad esempio, ARMPipeline-conn. Prendere nota di questo nome perché sarà necessario al momento di creare la pipeline.
- Concedi l'autorizzazione di accesso a tutte le pipeline. (selezionata)
Seleziona Salva.

Creare una pipeline

Fino a questo punto sono state completate le attività riportate di seguito. Se si saltano le sezioni precedenti perché si ha già familiarità con GitHub e DevOps, è necessario completare tali attività prima di proseguire.

Creare un repository GitHub e salvare i modelli nella cartella create_web_app nel repository.
Creare un progetto DevOps e creare una connessione al servizio Azure Resource Manager.

Per creare una pipeline con un passaggio per distribuire un modello:

Scegliere Pipelines (Pipeline) dal menu a sinistra.
Selezionare Crea pipeline.
Nella scheda Connect (Connetti) selezionare GitHub. Se vengono richieste, immettere le proprie credenziali GitHub e quindi seguire le istruzioni. Se viene visualizzata la schermata seguente, selezionare Only select repositories (Solo repository selezionati) e verificare che il proprio repository sia incluso nell'elenco prima di fare clic su Approve & Install (Approva e installa).
Nella scheda Select (Select) selezionare il repository. Il nome predefinito è [YourAccountName]/[YourGitHubRepositoryName].
Nella scheda Configure (Configura) selezionare Starter pipeline (Pipeline di base). Viene visualizzato il file della pipeline azure-pipelines.yml con due passaggi script.
Eliminare i due passaggi dello script dal file con estensione yml.
Spostare il cursore sulla riga dopo passaggi:.
Selezionare Mostra l'assistente a destra della schermata per aprire il riquadro Attività.
Selezionare Distribuzione modello ARM.
Immettere i valori seguenti:
- deploymentScope: selezionare Gruppo di risorse. Per altre informazioni sugli ambiti, vedere Ambiti di distribuzione.
- Connessione di Azure Resource Manager: selezionare il nome della connessione al servizio creato in precedenza.
- Sottoscrizione: specificare l'ID sottoscrizione di destinazione.
- Azione: selezionare l'azione Crea o Aggiorna gruppo di risorse esegue 2 azioni - 1. Crea un gruppo di risorse se viene specificato un nuovo nome di gruppo di risorse. 2. Distribuisce il modello specificato.
- Gruppo di risorse: immettere un nuovo nome del gruppo di risorse. Ad esempio, ARMPipeline-rg.
- Località: selezionare una località per il gruppo di risorse, ad esempio Stati Uniti centrali.
- Percorso modello: selezionare l'URL del file, il che significa che l'attività cerca il file modello usando l'URL. Poiché relativePath viene usato nel modello principale e relativePath è supportato solo nelle distribuzioni basate su URI, è necessario usare l'URL qui.
- Collegamento modello: immettere l'URL ottenuto alla fine della sezione Preparare un repository GitHub. Inizia con https://raw.githubusercontent.com.
- Collegamento ai parametri del modello: lasciare vuoto questo campo. I valori dei parametri verranno specificati in Esegui override dei parametri del modello.
- Eseguire l'override dei parametri del modello: immettere -projectName [EnterAProjectName].
- Modalità di distribuzione: selezionare Incrementale.
- Nome distribuzione: immettere DeployPipelineTemplate. Selezionare Avanzate per poter visualizzare Nome distribuzione.
Selezionare Aggiungi.

Per altre informazioni su questa attività, vedere Attività di distribuzione dei gruppi di risorse di Azure e Attività di distribuzione dei modelli di Azure Resource Manager.

Il file con estensione yml sarà simile al seguente:
Seleziona Salva ed Esegui.
Nel riquadro Salva ed esegui selezionare di nuovo Salva ed esegui. Una copia del file YAML verrà salvata nel repository connesso. È possibile visualizzare tale file accedendo al repository.
Verificare che la pipeline venga eseguita correttamente.

Verificare la distribuzione

Accedere al portale di Azure.
Aprire il gruppo di risorse. Il nome è quello specificato nel file YAML della pipeline. Si vedrà che è stato creato un account di archiviazione. Il nome di tale account inizia con store.
Selezionare il nome per aprire l'account di archiviazione.
Selezionare Proprietà. Osservare che l'opzione Replica è impostata su Archiviazione con ridondanza locale.

Aggiornare e ridistribuire

Quando si aggiorna il modulo e si esegue il push delle modifiche nel repository remoto, la pipeline aggiorna automaticamente le risorse, l'account di archiviazione in questo caso.

Aprire linkedStorageAccount.json dal repository locale in Visual Studio Code o in qualsiasi editor di testo.
Aggiornare la voce defaultValue di storageAccountType impostandola su Standard_GRS. Vedere lo screenshot seguente:
Salvare le modifiche.
Eseguire il push delle modifiche nel repository remoto eseguendo i comandi seguenti da Git Bash/Shell.
```
git pull origin main
git add .
git commit -m "Update the storage account type."
git push origin main
```
Il primo comando (pull) sincronizza il repository locale con il repository remoto. Il file YAML della pipeline è stato aggiunto solo al repository remoto. In seguito all'esecuzione del comando pull viene scaricata una copia del file YAML nel ramo locale.

Il quarto comando (push) carica il file linkedStorageAccount.json modificato nel repository remoto. Con il ramo principale del repository remoto aggiornato, la pipeline viene attivata di nuovo.

Per verificare le modifiche, è possibile controllare la proprietà Replica dell'account di archiviazione. Vedere Verificare la distribuzione.

Pulire le risorse

Quando non sono più necessarie, eseguire la pulizia delle risorse di Azure distribuite eliminando il gruppo di risorse.

Nel portale di Azure selezionare Gruppo di risorse nel menu a sinistra.
Immettere il nome del gruppo di risorse nel campo Filtra per nome.
Selezionare il nome del gruppo di risorse.
Selezionare Elimina gruppo di risorse nel menu in alto.

È anche possibile decidere di eliminare il repository GitHub e il progetto Azure DevOps.

Passaggi successivi

Questa esercitazione sulla distribuzione dei modelli di Resource Manager è stata completata. Usare la sezione dei commenti per inviare eventuali commenti e suggerimenti. Grazie. È ora possibile passare a concetti più avanzati relativi ai modelli. L'esercitazione successiva illustra in modo più dettagliato l'uso della documentazione di riferimento dei modelli per la definizione delle risorse da distribuire.

Utilizzare il riferimento del modello

Condividi tramite