Esercitazione: Distribuire app in App Spring di Azure usando Jenkins e l'interfaccia della riga di comando di Azure

Annotazioni

Azure Spring Apps è il nuovo nome del servizio Azure Spring Cloud. Anche se il servizio ha un nuovo nome, il nome precedente verrà visualizzato in alcune posizioni per un po' mentre si lavora per aggiornare gli asset, ad esempio screenshot, video e diagrammi.

Azure Spring Apps è uno sviluppo di microservizi completamente gestito con l'individuazione dei servizi e la gestione della configurazione predefinita. Il servizio semplifica la distribuzione di applicazioni di microservizi basate su Spring Boot in Azure. Questa esercitazione illustra come usare l'interfaccia della riga di comando di Azure in Jenkins per automatizzare l'integrazione e il recapito continui (CI/CD) per App Spring di Azure.

In questa esercitazione si completeranno le attività seguenti:

Effettuare il provisioning di un'istanza del servizio e avviare un'applicazione Java Spring
Preparare il server Jenkins
Usare l'interfaccia della riga di comando di Azure in una pipeline Jenkins per compilare e distribuire le applicazioni di microservizio

Prerequisiti

Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Jenkins: Installare Jenkins in una macchina virtuale Linux
Account GitHub: se non si ha un account GitHub, creare un account gratuito prima di iniziare.

Effettuare il provisioning di un'istanza del servizio e avviare un'applicazione Java Spring

Usiamo Piggy Metrics come applicazione di servizio Microsoft di esempio e seguiamo la stessa procedura di Avvio rapido: Avviare un'applicazione Java Spring usando l'interfaccia riga di comando di Azure per effettuare il provisioning dell'istanza del servizio e configurare le applicazioni. Se è già stato eseguito lo stesso processo, è possibile passare alla sezione successiva. Altrimenti, i comandi dell'interfaccia della riga di comando di Azure sono inclusi nei paragrafi seguenti. Per altre informazioni, vedere Avvio rapido: Avviare un'applicazione Java Spring usando l'interfaccia della riga di comando di Azure.

Il computer locale deve soddisfare lo stesso prerequisito del server di compilazione Jenkins. Assicurarsi che siano installati gli elementi seguenti per compilare e distribuire le applicazioni di microservizio:

Git
JDK 8
Maven 3.0 o versione successiva
Azure CLI installata, versione 2.0.67 o successiva

Installare l'estensione Azure Spring Apps:
```
az extension add --name spring
```
Creare un gruppo di risorse per contenere il servizio Azure Spring Apps:
```
az group create --location eastus --name <resource group name>
```
Effettuare il provisioning di un'istanza di Azure Spring Apps:
```
az spring create -n <service name> -g <resource group name>
```
Effettua un fork del repository Piggy Metrics nel tuo account GitHub. Nel computer locale, clona il repository in una directory denominata source-code:
```
mkdir source-code
git clone https://github.com/<your GitHub id>/piggymetrics
```

Configurare il server di configurazione. Assicurarsi di sostituire <l'ID> GitHub con il valore corretto.

az spring config-server git set -n <your-service-name> --uri https://github.com/<your GitHub id>/piggymetrics --label config

Compilare il progetto:

cd piggymetrics
mvn clean package -D skipTests

Creare i tre microservizi: gateway, auth-service e account-service:

az spring app create --n gateway -s <service name> -g <resource group name>
az spring app create --n auth-service -s <service name> -g <resource group name>
az spring app create --n account-service -s <service name> -g <resource group name>

Distribuire le applicazioni:

az spring app deploy -n gateway -s <service name> -g <resource group name> --jar-path ./gateway/target/gateway.jar
az spring app deploy -n account-service -s <service name> -g <resource group name> --jar-path ./account-service/target/account-service.jar
az spring app deploy -n auth-service -s <service name> -g <resource group name> --jar-path ./auth-service/target/auth-service.jar

Assegnare un endpoint pubblico al gateway:

az spring app update -n gateway -s <service name> -g <resource group name> --is-public true

Eseguire una query sull'applicazione gateway per ottenere l'URL in modo da poter verificare che l'applicazione sia in esecuzione.
```
az spring app show --name gateway | grep url
```
Passare all'URL fornito dal comando precedente per eseguire l'applicazione PiggyMetrics.

Preparare il server Jenkins

In questa sezione si prepara il server Jenkins per l'esecuzione di una compilazione, che è adatta per i test. Tuttavia, a causa dell'implicazione della sicurezza, è consigliabile usare un agente di macchine virtuali di Azure o un agente di Azure Container per avviare un agente in Azure per eseguire le compilazioni.

Installare plug-in

Accedere al server Jenkins.
Selezionare Gestisci Jenkins.
Selezionare Gestisci plug-in.
Nella scheda Disponibile selezionare i plug-in seguenti:
- Integrazione di GitHub
- Credenziali di Azure
Se questi plug-in non vengono visualizzati nell'elenco, controllare la scheda Installato per verificare se sono già installati.
Per installare i plug-in, selezionare Scarica ora e installa dopo il riavvio.
Riavviare il server Jenkins per completare l'installazione.

Aggiungi le credenziali dell'entità servizio di Azure nell'archivio credenziali di Jenkins

È necessario un principale del servizio di Azure per la distribuzione in Azure. Per altre informazioni, vedere la sezione Creare un principale del servizio nella guida Distribuzione nel servizio app di Azure. L'output di az ad sp create-for-rbac ha un aspetto simile al seguente:
```
{
    "appId": "xxxxxx-xxx-xxxx-xxx-xxxxxxxxxxxx",
    "displayName": "xxxxxxxjenkinssp",
    "name": "http://xxxxxxxjenkinssp",
    "password": "xxxxxx-xxx-xxxx-xxx-xxxxxxxxxxxx",
    "tenant": "xxxxxx--xxx-xxxx-xxx-xxxxxxxxxxxx"
}
```
Nel dashboard di Jenkins selezionare Credenziali>Sistema. Selezionare quindi Credenziali globali (senza restrizioni).
Selezionare Aggiungi credenziali.
Selezionare Principale del Servizio di Microsoft Azure come tipo.
Specificare i valori per i campi seguenti:
- ID sottoscrizione: ID sottoscrizione di Azure
- ID client: id appid dell'entità servizio
- Segreto client: password dell'entità servizio
- ID tenant: ID tenant dell'account Microsoft
- Ambiente Azure: selezionare il valore appropriato per l'ambiente in uso. Ad esempio, usare Azure per Azure Global
- ID: impostare su azure_service_principal. Questo ID viene usato in un passaggio successivo di questo articolo
- Descrizione: questo valore è facoltativo, ma consigliato dal punto di vista della documentazione/manutenzione.

Installare Maven e l'estensione Spring dell'interfaccia della riga di comando di Azure

La pipeline di esempio utilizza Maven per compilare e Azure CLI per distribuire l'istanza del servizio. Quando Jenkins è installato, crea un account amministratore denominato jenkins. Assicurarsi che l'utente jenkins disponga dell'autorizzazione per eseguire l'estensione spring.

Connettersi al controller Jenkins tramite SSH.
Installare Maven.
```
sudo apt-get install maven
```
Verificare che l'interfaccia della riga di comando di Azure sia installata immettendo az version. Se l'interfaccia della riga di comando di Azure non è installata, vedere Installazione dell'interfaccia della riga di comando di Azure.
Passare all'utente jenkins :
```
sudo su jenkins
```
Installare l'estensione Spring:
```
az extension add --name spring
```

Creare un jenkinsfile

Nel tuo repository: https://github.com/your_github_id/piggymetrics creare un Jenkinsfile alla radice.

Aggiornare il file come indicato di seguito. Assicurarsi di sostituire i valori del nome< del gruppo di risorse e del nome><del servizio.> Sostituire azure_service_principal con l'ID corretto se si usa un valore diverso quando sono state aggiunte le credenziali in Jenkins.

    node {
      stage('init') {
        checkout scm
      }
      stage('build') {
        sh 'mvn clean package'
      }
      stage('deploy') {
        withCredentials([azureServicePrincipal('azure_service_principal')]) {
          // Log in to Azure
          sh '''
            az login --service-principal -u $AZURE_CLIENT_ID -p $AZURE_CLIENT_SECRET -t $AZURE_TENANT_ID
            az account set -s $AZURE_SUBSCRIPTION_ID
          '''  
          // Set default resource group name and service name. Replace <resource group name> and <service name> with the right values
          sh 'az config set defaults.group=<resource group name>'
          sh 'az config set defaults.spring=<service name>'

          // Deploy applications
          sh 'az spring app deploy -n gateway --jar-path ./gateway/target/gateway.jar'
          sh 'az spring app deploy -n account-service --jar-path ./account-service/target/account-service.jar'
          sh 'az spring app deploy -n auth-service --jar-path ./auth-service/target/auth-service.jar'
          sh 'az logout'
        }
      }
    }

Salvare e confermare la modifica.

Creare l'attività

Nel dashboard di Jenkins selezionare Nuovo elemento.
Specificare un nome, Deploy-PiggyMetrics per il processo e selezionare Pipeline. Fare clic su OK.
Selezionare la scheda Pipeline .
Per Definizione, selezionare script di pipeline da un SCM.
Per SCM selezionare Git.
Immettere l'URL di GitHub per il repository biforcato: https://github.com/<your GitHub id>/piggymetrics.git.
Per Identificatore di ramo (nero per "any"), selezionare /Azure.
Per Percorso script selezionare Jenkinsfile.
Seleziona Salva

Convalidare ed eseguire il processo

Prima di eseguire il processo, modificare il testo nella casella di input per inserire l'ID di accesso.

Nel tuo repository, apri index.html in /gateway/src/main/resources/static/.

Cercare enter your login e aggiornare quel testo in enter login ID.

<input class="frontforms" id="frontloginform" name="username" placeholder="enter login ID" type="text" autocomplete="off"/>

Salva e conferma la modifica.
Eseguire manualmente il processo in Jenkins. Nel dashboard di Jenkins selezionare il processo Deploy-PiggyMetrics e quindi selezionare Compila adesso.

Al termine del lavoro, passare all'indirizzo IP pubblico dell'applicazione gateway e verificare che l'applicazione sia stata aggiornata.

Metriche Piggy aggiornate

Pulire le risorse

Quando non sono più necessarie, eliminare le risorse create in questo articolo:

az group delete -y --no-wait -n <resource group name>

Passaggi successivi

Jenkins in Azure

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-10-10