Tutorial: Eseguire la distribuzione su App Service di Azure con Jenkins e la CLI di Azure

2025-05-08

Importante

Sebbene molti servizi di Azure dispongano di plug-in Jenkins, la maggior parte di questi plug-in termina il supporto a partire dal 29 febbraio 2024. L'interfaccia della riga di comando di Azure è il modo attualmente consigliato per integrare Jenkins con i servizi di Azure. Per altre informazioni, vedere l'articolo Plug-in Jenkins per Azure.

Per distribuire un'app Web Java in Azure, è possibile usare l'interfaccia della riga di comando di Azure in una pipeline Jenkins. In questa esercitazione vengono eseguite le attività seguenti:

Creare una macchina virtuale Jenkins
Configurare Jenkins
Creare un'app Web in Azure
Preparare un repository GitHub
Creare una pipeline jenkins
Esegui la pipeline e verifica l'app web

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
Interfaccia della riga di comando di Azure: installare l'interfaccia della riga di comando di Azure (versione 2.0.67 o successiva) nel server Jenkins.

Configurare Jenkins

I passaggi seguenti illustrano come installare java JDK e Maven necessari nel controller Jenkins:

Accedere al controller Jenkins usando SSH.

Scaricare e installare la build Azul Zulu di OpenJDK per Azure da un repository apt-get:

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 0xB1998361219BD9C9
sudo apt-add-repository "deb http://repos.azul.com/azure-only/zulu/apt stable main"
sudo apt-get -q update
sudo apt-get -y install zulu-8-azure-jdk

Eseguire il comando seguente per installare Maven:
```
sudo apt-get install -y maven
```

Aggiungere un'entità servizio di Azure a una credenziale Jenkins

La procedura seguente illustra come specificare le credenziali di Azure:

Assicurarsi che il plug-in Credenziali sia installato.
Nel dashboard di Jenkins selezionare Credenziali -> Sistema -> .
Selezionare Credenziali globali (senza restrizioni).
Selezionare Aggiungi credenziali per aggiungere un principal del servizio di Microsoft Azure. Assicurarsi che il tipo di credenziale sia Username with password (Nome utente con password ) e immettere gli elementi seguenti:
- Nome utente: Service Principal appId
- Password: principale del servizio password
- ID: identificatore delle credenziali (ad esempio AzureServicePrincipal)

Creare un servizio app di Azure per la distribuzione dell'app Web Java

Usare az appservice plan create per creare un piano di servizio app di Azure con il piano tariffario GRATUITO :

az appservice plan create \
    --name <app_service_plan> \ 
    --resource-group <resource_group> \
    --sku FREE

Punti principali:

Il piano di servizio app definisce le risorse fisiche usate per ospitare le app.
Tutte le applicazioni assegnate a un piano di servizio app condividono queste risorse.
I piani di servizio app consentono di risparmiare i costi quando si ospitano più app.

Creare un'app Web di Azure

Usare az webapp create per creare una definizione di app Web nel myAppServicePlan piano di servizio app.

az webapp create \
    --name <app_name> \ 
    --resource-group <resource_group> \
    --plan <app_service_plan>

Punti principali:

La definizione dell'app Web fornisce un URL per accedere all'applicazione con e configura diverse opzioni per distribuire il codice in Azure.
Sostituire il <app_name> segnaposto con un nome di app univoco.
Il nome dell'app fa parte del nome di dominio predefinito per l'app Web. Di conseguenza, il nome deve essere univoco in tutte le app in Azure.
È possibile associare una voce di dominio personalizzato all'applicazione web prima di renderla accessibile agli utenti.

Configurare Java

Usare az appservice web config update per configurare la configurazione di runtime Java per l'app:

az webapp config set \ 
    --name <app_name> \
    --resource-group <resource_group> \ 
    --java-version 1.8 \ 
    --java-container Tomcat \
    --java-container-version 8.0

Preparare un repository GitHub

Aprire il repository Simple Java Web App for Azure .
Selezionare il pulsante Fork per effettuare un fork del repository nel proprio account GitHub.
Aprire il file Jenkinsfile facendo clic sul nome del file.
Selezionare l'icona a forma di matita per modificare il file.

Aggiorna l'ID della sottoscrizione e l'ID del tenant.

  withEnv(['AZURE_SUBSCRIPTION_ID=<subscription_id>',
        'AZURE_TENANT_ID=<tenant_id>'])

Aggiorna il gruppo di risorse e il nome della tua app Web rispettivamente nelle righe 22 e 23.
```
def resourceGroup = '<resource_group>'
def webAppName = '<app_name>'
```

Aggiornare l'ID credenziale nell'istanza di Jenkins

withCredentials([usernamePassword(credentialsId: '<service_principal>', passwordVariable: 'AZURE_CLIENT_SECRET', usernameVariable: 'AZURE_CLIENT_ID')]) {

Creare una pipeline jenkins

Eseguire le operazioni seguenti per creare una pipeline Jenkins:

Aprire Jenkins in un Web browser.
Selezionare Nuovo elemento.
Immettere un nome per l'attività.
Selezionare Pipeline.
Seleziona OK.
Selezionare Pipeline.
Per il campo Definizione, selezionare Script della pipeline da SCM.
Per SCM selezionare Git.
Immettere l'URL di GitHub per il repository con fork: https:\<forked_repo\>.git
Seleziona Salva

Testare la pipeline

Vai alla pipeline che hai creato
Selezionare Compila adesso
Al termine della compilazione, selezionare Output della console per visualizzare i dettagli della compilazione.

Verificare l'app Web

Eseguire le operazioni seguenti per verificare che il file WAR sia stato distribuito correttamente nell'app Web:

Passare all'URL seguente: http://<app_name>.azurewebsites.net/api/calculator/ping

Il testo dovrebbe essere simile al seguente:

Welcome to Java Web App!!! This is updated!
Today's date

Passare all'URL seguente (sostituire x e y con due valori da sommare): http://app_name.azurewebsites.net/api/calculator/add?x=x&y=y.

Eseguire la distribuzione nel servizio app di Azure in Linux

Il servizio app può anche ospitare le app Web in modo nativo in Linux per gli stack di applicazioni supportate. Può anche eseguire contenitori Linux personalizzati ,noti anche come App Web per contenitori.

È possibile modificare lo script per la distribuzione in un servizio app di Azure in Linux. Il servizio app in Linux supporta Docker. Di conseguenza, si fornisce un Dockerfile che racchiude la tua app Web e il runtime del servizio in un'immagine Docker. Il plug-in compila l'immagine, lo inserisce in un registro Docker e distribuisce l'immagine nell'app Web.

Vedere Eseguire la migrazione di software personalizzato al servizio app di Azure usando un contenitore personalizzato per creare un servizio app di Azure in Linux e un Registro Azure Container.

    az group create --name myResourceGroup2 --location westus2
    az acr create --name myACRName --resource-group myResourceGroup2 --sku Basic --admin-enabled true
    az appservice plan create --name myAppServicePlan --resource-group  myResourceGroup2 --is-linux
    az webapp create --resource-group myResourceGroup2 --plan myAppServicePlan --name myApp --deployment-container-image-name myACRName.azurecr.io/calculator:latest

Installare Docker in Jenkins.
Assicurarsi che sia installato il plug-in Docker Pipeline .
Nella stessa app Web Java semplice per Azure copiata tramite fork modificare il file Jenkinsfile2 come indicato di seguito:
1. Aggiorna l'ID della sottoscrizione e l'ID del tenant.
```
 withEnv(['AZURE_SUBSCRIPTION_ID=<mySubscriptionId>',
        'AZURE_TENANT_ID=<myTenantId>']) {
```
2. Aggiornate i nomi del vostro gruppo di risorse, dell'applicazione web e dell'Azure Container Registry, sostituendo i segnaposto con i vostri valori.
```
def webAppResourceGroup = '<resource_group>'
def webAppName = '<app_name>'
def acrName = '<registry>'
```
3. Aggiorna <azsrvprincipal\> con il tuo ID credenziale
```
withCredentials([usernamePassword(credentialsId: '<service_principal>', passwordVariable: 'AZURE_CLIENT_SECRET', usernameVariable: 'AZURE_CLIENT_ID')]) {
```
Creare una nuova pipeline Jenkins come hai fatto per distribuire nell'app web di Azure su Windows usando Jenkinsfile2.
Esegui la tua nuova attività.
Per verificare, nell'interfaccia della riga di comando di Azure eseguire il comando seguente:
```
az acr repository list -n <myRegistry> -o json
```
Verranno visualizzati risultati simili ai seguenti:
```
[
"calculator"
]
```
Passa a http://<app_name>.azurewebsites.net/api/calculator/ping per sostituire il segnaposto. I risultati visualizzati saranno simili ai seguenti:
```
Welcome to Java Web App!!! This is updated!
Today's date
```
Passare a http://<app_name>.azurewebsites.net/api/calculator/add?x=<x>&y=<y> (sostituendo i segnaposto). I valori specificati per x e y vengono sommati e visualizzati.

Passaggi successivi

Jenkins in Azure

Condividi tramite