Självstudie: Distribuera till Azure App Service med Jenkins och Azure CLI

2025-05-08

Viktigt!

Många Azure-tjänster har Jenkins-plugin-program, men de flesta av dessa plugin-program avslutade supporten från och med den 29 februari 2024. Azure CLI är det för närvarande rekommenderade sättet att integrera Jenkins med Azure-tjänster. Mer information finns i artikeln Jenkins-plugin-program för Azure.

Om du vill distribuera en Java-webbapp till Azure kan du använda Azure CLI i en Jenkins-pipeline. I den här självstudien utför du följande uppgifter:

Skapa en virtuell Jenkins-dator
Konfigurera Jenkins
Skapa en webbapp i Azure
Förbereda en GitHub-lagringsplats
Skapa Jenkins-pipeline
Kör pipelinen och verifiera webbappen

Förutsättningar

Azure-prenumeration: Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar.

Jenkins - Installera Jenkins på en virtuell Linux-dator
Azure CLI: Installera Azure CLI (version 2.0.67 eller senare) på Jenkins-servern.

Konfigurera Jenkins

Följande steg visar hur du installerar java-JDK och Maven på Jenkins-styrenheten:

Logga in på Jenkins-kontrollanten med hjälp av SSH.

Ladda ned och installera Azul Zulu-versionen av OpenJDK för Azure från en apt-get-lagringsplats:

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

Kör följande kommando för att installera Maven:
```
sudo apt-get install -y maven
```

Lägga till Azure-tjänstens huvudnamn i en Jenkins-autentiseringsuppgift

Följande steg visar hur du anger dina Azure-autentiseringsuppgifter:

Kontrollera att plugin-programmet Autentiseringsuppgifter är installerat.
På Jenkins-instrumentpanelen väljer du Autentiseringsuppgifter –> System ->.
Välj Globala autentiseringsuppgifter(obegränsad).
Välj Lägg till autentiseringsuppgifter för att lägga till ett Huvudnamn för Microsoft Azure-tjänsten. Kontrollera att typen av autentiseringsuppgifter är Användarnamn med lösenord och ange följande:
- Användarnamn: Tjänstens huvudnamn appId
- Lösenord: Tjänstens huvudnamn password
- ID: Identifierare för autentiseringsuppgifter (till exempel AzureServicePrincipal)

Skapa en Azure App Service för att distribuera Java-webbappen

Använd az appservice plan create för att skapa en Azure App Service-plan med prisnivån KOSTNADSFRI :

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

Viktiga punkter:

Appserviceplanen definierar de fysiska resurser som används som värd för dina appar.
Alla program som tilldelats en apptjänstplan delar dessa resurser.
Med Appservice-planer kan du spara kostnader när du är värd för flera appar.

Skapa en Azure-webbapp

Använd az webapp create för att skapa en webbappsdefinition i myAppServicePlan App Service-planen.

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

Viktiga punkter:

Webbappdefinitionen innehåller en URL för åtkomst till ditt program med och konfigurerar flera alternativ för att distribuera din kod till Azure.
<app_name> Ersätt platshållaren med ett unikt appnamn.
Appnamnet är en del av standarddomännamnet för webbappen. Därför måste namnet vara unikt för alla appar i Azure.
Du kan koppla ett anpassat domännamn till webbappen innan du gör den tillgänglig för dina användare.

Konfigurera Java

Använd az appservice web config update för att konfigurera Java-körningskonfigurationen för appen:

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

Förbereda en GitHub-lagringsplats

Öppna Simple Java Web App for Azure-repo.
Välj knappen Förgrening för att förgrena lagringsplatsen till ditt eget GitHub-konto.
Öppna Jenkinsfile-filen genom att klicka på filnamnet.
Välj pennikonen för att redigera filen.

Uppdatera prenumerations-ID och klient-ID.

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

Uppdatera resursgruppen och namnet på webbappen på rad 22 respektive 23.
```
def resourceGroup = '<resource_group>'
def webAppName = '<app_name>'
```

Uppdatera autentiserings-ID:t i Jenkins-instansen

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

Skapa Jenkins-pipeline

Gör följande för att skapa en Jenkins-pipeline:

Öppna Jenkins i en webbläsare.
Välj Nytt objekt.
Ange ett namn för jobbet.
Välj Pipeline.
Välj OK.
Välj Pipeline.
För Definition väljer du Pipeline-skript från SCM.
För SCM väljer du Git.
Ange GitHub-URL:en för din förgrenade lagringsplats: https:\<forked_repo\>.git
Välj Spara

Testa din pipeline

Gå till pipelinen som du skapade
Välj Skapa nu
När bygget är klart väljer du Konsolutdata för att se bygginformation.

Verifiera din webbapp

Gör följande för att kontrollera att WAR-filen har distribuerats till webbappen:

Bläddra till följande URL: http://<app_name>.azurewebsites.net/api/calculator/ping

Du bör se text som liknar följande:

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

Bläddra till följande URL (ersätt <x> och <y> med två värden som ska summeras): http://<app_name>.azurewebsites.net/api/calculator/add?x=<x>&y=<y>.

Distribuera till Azure App Service i Linux

App Service kan också vara värd för webbappar internt i Linux för programstackar som stöds. Den kan också köra anpassade Linux-containrar (kallas även webapp för containrar.)

Du kan ändra skriptet så att det distribueras till en Azure App Service i Linux. App Service på Linux stöder Docker. Därför anger du en Dockerfile som paketerar webbappen med tjänstkörning i en Docker-avbildning. Plugin-programmet skapar avbildningen, push-överför den till ett Docker-register och distribuerar avbildningen till webbappen.

Se Migrera anpassad programvara till Azure App Service med hjälp av en anpassad container för att skapa en Azure App Service i Linux och ett Azure Container Registry.

    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

Installera Docker på Jenkins.
Kontrollera att Docker Pipeline-plugin-programmet är installerat.

Redigera Jenkinsfile2-filen på följande sätt i samma Simple Java Web App for Azure-repo som du klonade:

Uppdatera prenumerations-ID och klient-ID.

 withEnv(['AZURE_SUBSCRIPTION_ID=<mySubscriptionId>',
        'AZURE_TENANT_ID=<myTenantId>']) {

Uppdatera till namnen på resursgruppen, webbappen och ACR (ersätt platshållarna med dina värden).

def webAppResourceGroup = '<resource_group>'
def webAppName = '<app_name>'
def acrName = '<registry>'

Uppdatera <azsrvprincipal\> till ditt autentiserings-ID

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

Skapa en ny Jenkins-pipeline som du gjorde när du distribuerade till Azure webbapp på Windows med Jenkinsfile2.
Kör ditt nya jobb.
Kontrollera att du kör följande kommando i Azure CLI:
```
az acr repository list -n <myRegistry> -o json
```
Du bör se resultat som liknar följande:
```
[
"calculator"
]
```
Bläddra till http://<app_name>.azurewebsites.net/api/calculator/ping och ersätt platshållaren. Du bör se liknande resultat som följande:
```
Welcome to Java Web App!!! This is updated!
Today's date
```
Bläddra till http://<app_name>.azurewebsites.net/api/calculator/add?x=<x>&y=<y> (ersätta platshållarna). De värden som du anger för x och y summeras och visas.

Nästa steg

Jenkins på Azure

Dela via