Esercitazione: Compilare e distribuire dal codice sorgente ad App Azure Container

Questo articolo illustra come compilare e distribuire un'applicazione in App Contenitore di Azure dal codice sorgente nel computer nel linguaggio di programmazione preferito.

In questa esercitazione:

• Creare una semplice applicazione Web.
• Creare un Dockerfile associato per l'app.
• Creare un'immagine dal codice compilato ed eseguirne il push in un registro contenitori.
• Usare l'identità gestita per accedere in modo sicuro al registro contenitori.
• Distribuire il contenitore in App Azure Container.
• Visualizzare l'app in un browser per verificare la distribuzione.

Prerequisiti

Per completare il progetto, sono necessari gli elementi seguenti:

Requisito	Istruzioni
Account Azure	Se non si dispone di un account, crearne uno gratuitamente. Per continuare, è necessaria l'autorizzazione collaboratore o proprietario per la sottoscrizione di Azure. Per informazioni dettagliate, fare riferimento ad Assegnare ruoli di Azure usando il portale di Azure.
Interfaccia della riga di comando di Azure	Installare l'interfaccia della riga di comando di Azure o eseguire l'aggiornamento alla versione più recente. L'interfaccia della riga di comando per sviluppatori di Azure (azd comandi) è disponibile tramite l'interfaccia della riga di comando di Azure.

A seconda del linguaggio scelto, potrebbe anche essere necessario installare il runtime, l'SDK e altre dipendenze appropriate.

C#

Installare .NET SDK.

Java

• Installare Java Development Kit.

• Installare Apache Maven.

JavaScript

Installare Node.js.

Python

Installare Python.

Creare l'applicazione locale

I passaggi seguenti illustrano il codice e le dipendenze necessari per compilare un'applicazione di esempio da distribuire in App Azure Container.

Nota

Se si vuole usare un'altra lingua diversa da quelle elencate, immettere il prompt seguente nel modello di intelligenza artificiale preferito.

Prima di inviare il prompt, sostituire <LANGUAGE> con la lingua desiderata.

Generate the simplest possible "hello world" web server in idiomatic <LANGUAGE>.

Make sure to include any dependencies required for the application to run locally and in production. 

1. Creare ed eseguire il codice sorgente.

   C#

   Creare un nuovo progetto C#.

   dotnet new webapp --name MyAcaDemo --language C#
   

   Passare alla cartella MyAcaDemo .

   cd MyAcaDemo
   

   Aprire Program.cs in un editor di codice e sostituire il contenuto con il codice seguente.

   public class Program
   {
       public static void Main(string[] args)
       {
           CreateHostBuilder(args).Build().Run();
       }
   
       public static IHostBuilder CreateHostBuilder(string[] args) =>
           Host.CreateDefaultBuilder(args)
               .ConfigureWebHostDefaults(webBuilder =>
               {
                   webBuilder.UseStartup<Startup>();
                   webBuilder.UseUrls("http://*:8080");
               });
   }
   

   L'implementazione della Program classe con questo codice crea la base di un'applicazione Web. Creare quindi una classe responsabile della restituzione di una pagina Web come risposta.

   Nella stessa cartella creare un nuovo file denominato Startup.cs e immettere il codice seguente.

   public class Startup
   {
       public void ConfigureServices(IServiceCollection services)
       {
       }
   
       public void Configure(IApplicationBuilder app)
       {   
           app.UseRouting();
   
           app.UseEndpoints(endpoints =>
           {
               endpoints.MapGet("/", async context =>
               {
                   await context.Response.WriteAsync("Hello World!");
               });
           });
       }
   }
   

   Quando viene effettuata una richiesta all'applicazione Web, viene restituito il testo "Hello World!". Per verificare che il codice sia in esecuzione correttamente nel computer locale, compilare il progetto nella configurazione della versione.

   dotnet build -c Release
   

   Eseguire quindi l'applicazione per verificare che il codice sia implementato correttamente.

   dotnet run --configuration Release
   

   Java

   Creare una nuova applicazione Java recuperando prima l'applicazione di avvio Spring Boot usando il comando seguente.

   curl https://start.spring.io/starter.zip -d dependencies=web -d name=MyAcaDemo -d artifactId=MyAcaDemo -d baseDir=MyAcaDemo -o MyAcaDemo.zip
   

   Se il comando non unzip è installato, è possibile installarlo ora.

   sudo apt-get update && sudo apt-get install unzip
   

   È ora possibile decomprimere il pacchetto in una cartella denominata MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   Quando si decomprime questo pacchetto, viene creata una struttura di cartelle nidificata in cui una cartella denominata MyAcaDemo si trova all'interno di una cartella esterna denominata MyAcaDemo.

   Usare il comando seguente per passare alla cartella MyAcaDemo corretta.

   cd MyAcaDemo/MyAcaDemo
   

   Aprire questa cartella in un editor di codice in modo da poter aggiungere e modificare alcuni file.

   src/main/java/com/example/MyAcaDemo/ Nella cartella creare un file denominato MyAcaDemoController.java e immettere il codice seguente.

   package com.example.MyAcaDemo;
   
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   @RestController
   public class MyAcaDemoController {
       @GetMapping("/")
       public String hello() {
           return "Hello, World!";
       }
   }
   

   Nella cartella MyAcaDemo creare un file denominato pom.xml e aggiungere il codice seguente.

   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.example</groupId>
       <artifactId>MyAcaDemo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <name>MyAcaDemo</name>
       <description>Demo project for Spring Boot</description>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>3.1.0</version>
           <relativePath/> <!-- lookup parent from repository -->
       </parent>
       <properties>
           <java.version>17</java.version>
       </properties>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <version>3.1.0</version>
               <configuration>
                   <mainClass>com.example.MyAcaDemo.MyAcaDemoApplication</mainClass>
               </configuration>
           </plugin>
           </plugins>
       </build>
   </project>
   

   Eseguire il comando seguente per verificare le compilazioni del progetto senza errori.

   mvn clean package -DskipTests
   

   Dopo aver completato la compilazione, eseguire il comando seguente per assicurarsi che l'applicazione venga eseguita correttamente nel computer.

   mvn spring-boot:run
   

   JavaScript

   Creare una cartella denominata MyAcaDemo per contenere i file per l'applicazione demo.

   mkdir MyAcaDemo
   

   Passare quindi alla cartella MyAcaDemo .

   cd MyAcaDemo
   

   Usare il comando seguente per generare i file di base per un'applicazione Node.js.

   npm init -y
   

   Aprire questa cartella in un editor di codice e creare un file denominato index.js con il codice seguente.

   const http = require('http');
   
   const server = http.createServer((req, res) => {
       res.writeHead(200, { 'Content-Type': 'text/html' });
       res.end('<html>Hello World!</html>');
   });
   
   server.listen(8080, () => {
       console.log('Server running at http://localhost:8080/');
   });
   

   A questo punto è possibile eseguire il comando seguente per assicurarsi che l'applicazione venga eseguita correttamente nel computer.

   node index.js
   

   Python

   Creare una cartella denominata MyAcaDemo.

   mkdir MyAcaDemo
   

   Passare alla cartella MyAcaDemo .

   cd MyAcaDemo
   

   Installare Flask usando il comando seguente.

   pip install flask
   

   L'applicazione di esempio si basa sul framework Flask. È necessario che sia installato in locale in modo da poter verificare che l'app venga eseguita correttamente nel computer prima di provare a distribuirla nel cloud.

   Creare un nuovo file denominato app.py e immettere il codice seguente.

   from flask import Flask
   
   app = Flask(__name__)
   
   @app.route('/')
   def hello_world():
       return '<html>Hello World!</html>'
   
   if __name__ == '__main__':
       app.run()
   

   Questo codice crea un server Web di base che restituisce Hello World!.

   Nella stessa cartella creare un nuovo file denominato requirements.txt e immettere il codice seguente.

   Flask
   gunicorn
   

   Questo file indica al runtime Python di usare il framework Web Flask e il server Web gunicorn per ospitare l'applicazione di esempio.

   Eseguire il comando seguente per verificare che l'applicazione funzioni correttamente.

   python3 app.py
   

   Dopo aver verificato che l'applicazione funzioni come previsto, è possibile arrestare il server locale e passare alla creazione di un Dockerfile in modo da poter distribuire l'app in App contenitore.

2. Nella cartella MyAcaDemo creare un file denominato Dockerfile e aggiungere il contenuto seguente.

   C#

   FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
   WORKDIR /src
   COPY . .
   RUN dotnet publish -c Release -o /app/publish
   
   FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
   WORKDIR /app
   COPY --from=build /app/publish .
   EXPOSE 8080
   ENTRYPOINT ["dotnet", "MyAcaDemo.dll"]
   

   Java

   FROM maven:3.8.4-openjdk-17 AS build
   WORKDIR /app
   COPY pom.xml .
   COPY src ./src
   RUN mvn clean package -DskipTests
   
   FROM openjdk:17-jdk-alpine
   WORKDIR /app
   COPY --from=build /app/target/MyAcaDemo-0.0.1-SNAPSHOT.jar /app/MyAcaDemo.jar
   EXPOSE 8080
   ENTRYPOINT ["java", "-jar", "MyAcaDemo.jar"]
   

   JavaScript

   FROM node:18
   WORKDIR /usr/src/app
   COPY ./ . 
   RUN npm install
   EXPOSE 3000
   CMD ["node", "index.js"]
   

   Python

   FROM python:3.9-slim
   WORKDIR /app
   COPY . /app
   RUN pip install --no-cache-dir -r requirements.txt
   EXPOSE 8080
   ENV FLASK_APP=app.py
   CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]
   

   Ora che il codice e un Dockerfile sono pronti, è possibile distribuire l'app in App Contenitore di Azure.

Creazione di risorse Azure

1. Accedere ad Azure dall'interfaccia della riga di comando con il comando seguente. Per completare il processo di autenticazione, assicurarsi di seguire tutte le istruzioni.

   az login
   

2. Installare o aggiornare l'estensione App Azure Container per l'interfaccia della riga di comando di Azure.

   az extension add --name containerapp --upgrade
   

   Nota

   Se si ricevono errori relativi ai parametri mancanti quando si eseguono az containerapp comandi, assicurarsi di avere installato la versione più recente dell'estensione App Azure Container.

3. Dopo aver completato la configurazione dell'interfaccia della riga di comando di Azure, è possibile definire un set di variabili di ambiente.

   Prima di eseguire il comando seguente, esaminare i valori forniti.

   La posizione è configurata come Stati Uniti centrali, ma è possibile passare a una località più vicina, se si preferisce.

   LOCATION="CentralUS"
   RESOURCE_GROUP="my-demo-group"
   IDENTITY_NAME="my-demo-identity"
   ENVIRONMENT="my-demo-environment"
   REGISTRY_NAME="mydemoregistry$(openssl rand -hex 4)"
   CONTAINER_APP_NAME="my-demo-app"
   

   Il mydemoregistry$(openssl rand -hex 4) comando genera una stringa casuale da usare come nome del registro contenitori. I nomi del Registro di sistema devono essere univoci a livello globale, quindi questa stringa consente di garantire che i comandi vengano eseguiti correttamente.

4. Creare un gruppo di risorse per organizzare i servizi correlati alla distribuzione dell'app contenitore.

   az group create \
     --name $RESOURCE_GROUP \
     --location $LOCATION \
     --output none
   

5. Creare un'identità gestita assegnata dall'utente e ottenere il relativo ID con i comandi seguenti.

   Creare prima di tutto l'identità gestita.

   az identity create \
       --name $IDENTITY_NAME \
       --resource-group $RESOURCE_GROUP \
       --output none
   

   Impostare ora l'identificatore di identità in una variabile per un uso successivo.

   IDENTITY_ID=$(az identity show \
     --name $IDENTITY_NAME \
     --resource-group $RESOURCE_GROUP \
     --query id \
     --output tsv)
   

6. Creare un ambiente app contenitore per ospitare l'app usando il comando seguente.

   az containerapp env create \
       --name $ENVIRONMENT \
       --resource-group $RESOURCE_GROUP \
       --location $LOCATION \
       --mi-user-assigned $IDENTITY_ID \
       --output none
   

7. Creare un'istanza di Registro Azure Container (ACR) nel gruppo di risorse. Il registro archivia l'immagine del contenitore.

   az acr create \
     --resource-group $RESOURCE_GROUP \
     --name $REGISTRY_NAME \
     --sku Basic \
     --output none
   

8. Assegnare l'identità gestita assegnata dall'utente all'istanza del registro contenitori con il comando seguente.

   az acr identity assign \
     --identities $IDENTITY_ID \
     --name $REGISTRY_NAME \
     --resource-group $RESOURCE_GROUP \
     --output none
   

Compilare ed eseguire il push dell'immagine in un registro

Compilare ed eseguire il push dell'immagine del contenitore nell'istanza del registro contenitori con il comando seguente.

az acr build \
    -t $REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld" \
    -r $REGISTRY_NAME .

Questo comando applica il tag helloworld all'immagine del contenitore.

Creare l'app contenitore

Creare l'app contenitore con il comando seguente.

az containerapp create \
  --name $CONTAINER_APP_NAME \
  --resource-group $RESOURCE_GROUP \
  --environment $ENVIRONMENT \
  --image $REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld" \
  --target-port 8080 \
  --ingress external \
  --user-assigned $IDENTITY_ID \
  --registry-identity $IDENTITY_ID \
  --registry-server $REGISTRY_NAME.azurecr.io \
  --query properties.configuration.ingress.fqdn

Questo comando aggiunge il ruolo all'identità gestita assegnata dall'utente, in modo che possa eseguire il acrPull pull delle immagini dal registro contenitori.

Nella tabella seguente vengono descritti i parametri usati da questo comando.

Parametro	valore	Descrizione
name	$CONTAINER_APP_NAME	Nome dell'app contenitore.
resource-group	$RESOURCE_GROUP	Gruppo di risorse in cui viene distribuita l'app contenitore.
environment	$ENVIRONMENT	Ambiente in cui viene eseguita l'app contenitore.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	Immagine del contenitore da distribuire, inclusi il nome e il tag del Registro di sistema.
target-port	8080	Trova la corrispondenza con la porta a cui l'app è in ascolto per le richieste.
ingress	external	Rende l'app contenitore accessibile dalla rete Internet pubblica.
user-assigned	$IDENTITY_ID	Identità gestita assegnata dall'utente per l'app contenitore.
registry-identity	registry-identity	Identità usata per accedere al registro contenitori.
registry-server	$REGISTRY_NAME.azurecr.io	Indirizzo del server del registro contenitori.
query	properties.configuration.ingress.fqdn	Filtra l'output in modo che solo il nome di dominio completo (FQDN) dell'app.

Al termine di questo comando, restituisce l'URL per la nuova app Web.

Verificare la distribuzione

Copiare l'URL dell'app in un Web browser. Dopo l'avvio dell'app contenitore, restituisce Hello World!.

Poiché è la prima volta che si accede all'applicazione, l'app potrebbe richiedere alcuni istanti per restituire una risposta.

Pulire le risorse

Se non si intende usare le risorse di Azure create in questa esercitazione, è possibile rimuoverle con un singolo comando. Prima di eseguire il comando, è disponibile un passaggio successivo in questa serie di esercitazioni che illustra come apportare modifiche al codice e aggiornare l'app in Azure.

Se si vuole rimuovere tutte le risorse di Azure create in questa esercitazione, eliminare il gruppo di risorse con il comando seguente.

az group delete --name aca-demo

Suggerimento

Problemi? Segnalare i problemi su GitHub aprendo un ticket nel repository App contenitore di Azure.

Passaggi successivi

Continuare quindi per informazioni su come aggiornare l'app contenitore creata.

Aggiornare un'app contenitore distribuita dal codice sorgente