Zelfstudie: Bouwen en implementeren van broncode naar Azure Container Apps

In dit artikel leest u hoe u een toepassing bouwt en implementeert in Azure Container Apps vanuit broncode op uw computer in de programmeertaal van uw voorkeur.

In deze zelfstudie doet u het volgende:

• Maak een eenvoudige webtoepassing.
• Maak een gekoppeld Dockerfile voor uw app.
• Maak een installatiekopieën van de gecompileerde code en push deze naar een containerregister.
• Gebruik beheerde identiteit om veilig toegang te krijgen tot uw containerregister.
• Implementeer uw container in Azure Container Apps.
• Bekijk uw app in een browser om de implementatie te controleren.

Vereisten

U hebt het volgende nodig om dit project te voltooien:

Vereiste	Instructies
Azure-account	Als u nog geen account hebt, maakt u gratis een account. U hebt de machtiging Inzender of Eigenaar voor het Azure-abonnement nodig om door te gaan. Raadpleeg Azure-rollen toewijzen met behulp van Azure Portal voor meer informatie.
Azure-CLI	Installeer de Azure CLI of voer een upgrade uit naar de nieuwste versie. De Azure Developer CLI (azd opdrachten) is beschikbaar via de Azure CLI.

Afhankelijk van uw taalkeuze moet u mogelijk ook de juiste runtime, SDK en andere afhankelijkheden installeren.

C#

Installeer de .NET SDK.

Java

• Installeer de Java Development Kit.

• Installeer Apache Maven.

JavaScript

Installeer Node.js.

Python

Installeer Python.

De lokale toepassing maken

In de volgende stappen worden de code en afhankelijkheden weergegeven die nodig zijn om een voorbeeldtoepassing te bouwen voor implementatie in Azure Container Apps.

Notitie

Als u een andere taal wilt gebruiken dan de taal die wordt vermeld, voert u de volgende prompt in het AI-model van uw voorkeur in.

Voordat u de prompt indient, vervangt u deze door <LANGUAGE> de gewenste taal.

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. Maak en voer de broncode uit.

   C#

   Maak een nieuw C#-project.

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

   Ga naar de map MyAcaDemo .

   cd MyAcaDemo
   

   Open Program.cs in een code-editor en vervang de inhoud door de volgende code.

   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");
               });
   }
   

   Als u de Program klasse met deze code implementeert, wordt de basis van een webtoepassing gemaakt. Maak vervolgens een klasse die verantwoordelijk is voor het retourneren van een webpagina als antwoord.

   Maak in dezelfde map een nieuw bestand met de naam Startup.cs en voer de volgende code in.

   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!");
               });
           });
       }
   }
   

   Wanneer er nu een aanvraag wordt ingediend bij uw webtoepassing, wordt de tekst 'Hallo wereld!' geretourneerd. Als u wilt controleren of uw code correct wordt uitgevoerd op uw lokale computer, bouwt u uw project in de releaseconfiguratie.

   dotnet build -c Release
   

   Voer vervolgens uw toepassing uit om te controleren of uw code correct is geïmplementeerd.

   dotnet run --configuration Release
   

   Java

   Maak een nieuwe Java-toepassing door eerst de Spring Boot-starterstoepassing op te halen met behulp van de volgende opdracht.

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

   Als u de opdracht niet hebt geïnstalleerd, kunt u deze unzip nu installeren.

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

   U kunt het pakket nu uitpakken naar een map met de naam MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   Wanneer u dit pakket uitpakt, wordt er een geneste mapstructuur gemaakt waarin een map met de naam MyAcaDemo zich bevindt in een buitenste map met de naam MyAcaDemo.

   Gebruik de volgende opdracht om over te schakelen naar de juiste map MyAcaDemo .

   cd MyAcaDemo/MyAcaDemo
   

   Open deze map in een code-editor, zodat u bepaalde bestanden kunt toevoegen en bewerken.

   Maak in de map een bestand met de src/main/java/com/example/MyAcaDemo/ naam MyAcaDemoController.java en voer de volgende code in.

   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!";
       }
   }
   

   Maak in de map MyAcaDemo een bestand met de naam pom.xml en voeg de volgende code toe.

   <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>
   

   Voer de volgende opdracht uit om uw project builds zonder fouten te controleren.

   mvn clean package -DskipTests
   

   Wanneer u een geslaagde build hebt, voert u de volgende opdracht uit om ervoor te zorgen dat de toepassing correct wordt uitgevoerd op uw computer.

   mvn spring-boot:run
   

   JavaScript

   Maak een map met de naam MyAcaDemo om de bestanden voor de demotoepassing te bewaren.

   mkdir MyAcaDemo
   

   Ga vervolgens naar de map MyAcaDemo .

   cd MyAcaDemo
   

   Gebruik de volgende opdracht om de basisbestanden voor een Node.js toepassing te genereren.

   npm init -y
   

   Open deze map in een code-editor en maak een bestand met de naam index.js met de volgende code.

   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/');
   });
   

   U kunt nu de volgende opdracht uitvoeren om ervoor te zorgen dat de toepassing correct wordt uitgevoerd op uw computer.

   node index.js
   

   Python

   Maak een map met de naam MyAcaDemo.

   mkdir MyAcaDemo
   

   Ga naar de map MyAcaDemo .

   cd MyAcaDemo
   

   Installeer Flask met behulp van de volgende opdracht.

   pip install flask
   

   De voorbeeldtoepassing is gebaseerd op het Flask-framework. U hebt deze lokaal geïnstalleerd, zodat u kunt controleren of uw app correct wordt uitgevoerd op uw computer voordat u deze in de cloud implementeert.

   Maak een nieuw bestand met de naam app.py en voer de volgende code in.

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

   Met deze code maakt u een eenvoudige webserver die Hallo wereld! retourneert.

   Maak in dezelfde map een nieuw bestand met de naam requirements.txt en voer de volgende code in.

   Flask
   gunicorn
   

   Met dit bestand wordt de Python-runtime geïnstrueerd om het Flask-webframework en gunicorn-webserver te gebruiken om de voorbeeldtoepassing te hosten.

   Voer de volgende opdracht uit om te controleren of de toepassing correct werkt.

   python3 app.py
   

   Zodra u hebt gecontroleerd of de toepassing werkt zoals verwacht, kunt u de lokale server stoppen en verdergaan met het maken van een Dockerfile, zodat u de app kunt implementeren in Container Apps.

2. Maak in de map MyAcaDemo een bestand met de naam Dockerfile en voeg de volgende inhoud toe.

   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"]
   

   Nu u uw code en een Dockerfile gereed hebt, kunt u uw app implementeren in Azure Container Apps.

Azure-resources maken

1. Meld u met de volgende opdracht aan bij Azure vanuit de CLI. Als u het verificatieproces wilt voltooien, moet u alle aanwijzingen volgen.

   az login
   

2. Installeer of werk de Azure Container Apps-extensie voor de Azure CLI bij.

   az extension add --name containerapp --upgrade
   

   Notitie

   Als u fouten ontvangt over ontbrekende parameters wanneer u opdrachten uitvoert az containerapp , moet u ervoor zorgen dat de nieuwste versie van de Azure Container Apps-extensie is geïnstalleerd.

3. Nu uw Azure CLI-installatie is voltooid, kunt u een set omgevingsvariabelen definiëren.

   Controleer de opgegeven waarden voordat u de volgende opdracht uitvoert.

   De locatie is geconfigureerd als VS - centraal, maar u kunt desgewenst overschakelen naar een locatie die het dichtst bij u ligt.

   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"
   

   Met de mydemoregistry$(openssl rand -hex 4) opdracht wordt een willekeurige tekenreeks gegenereerd die moet worden gebruikt als de naam van het containerregister. Registernamen moeten globaal uniek zijn, dus deze tekenreeks helpt ervoor te zorgen dat uw opdrachten correct worden uitgevoerd.

4. Maak een resourcegroep om de services te ordenen die betrekking hebben op de implementatie van uw container-app.

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

5. Maak een door de gebruiker toegewezen beheerde identiteit en haal de id op met de volgende opdrachten.

   Maak eerst de beheerde identiteit.

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

   Stel nu de id in op een variabele voor later gebruik.

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

6. Maak een Container Apps-omgeving om uw app te hosten met behulp van de volgende opdracht.

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

7. Maak een ACR-exemplaar (Azure Container Registry) in uw resourcegroep. In het register wordt de containerinstallatiekopieën opgeslagen.

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

8. Wijs met de volgende opdracht uw door de gebruiker toegewezen beheerde identiteit toe aan uw containerregisterinstantie.

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

De installatiekopieën naar een register bouwen en pushen

Bouw en push uw containerinstallatiekopieën naar uw containerregisterinstantie met de volgende opdracht.

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

Met deze opdracht wordt de tag helloworld toegepast op de containerinstallatiekopieën.

Uw container-app maken

Maak uw container-app met de volgende opdracht.

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

Met deze opdracht wordt de rol toegevoegd aan uw door de acrPull gebruiker toegewezen beheerde identiteit, zodat deze installatiekopieën uit uw containerregister kan ophalen.

In de volgende tabel worden de parameters beschreven die door deze opdracht worden gebruikt.

Parameter	Weergegeven als	Beschrijving
name	$CONTAINER_APP_NAME	De naam van uw container-app.
resource-group	$RESOURCE_GROUP	De resourcegroep waarin uw container-app is geïmplementeerd.
environment	$ENVIRONMENT	De omgeving waarin uw container-app wordt uitgevoerd.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	De containerinstallatiekopieën die moeten worden geïmplementeerd, inclusief de registernaam en -tag.
target-port	8080	Komt overeen met de poort waarnaar uw app luistert voor aanvragen.
ingress	external	Maakt uw container-app toegankelijk via het openbare internet.
user-assigned	$IDENTITY_ID	De door de gebruiker toegewezen beheerde identiteit voor uw container-app.
registry-identity	registry-identity	De identiteit die wordt gebruikt voor toegang tot het containerregister.
registry-server	$REGISTRY_NAME.azurecr.io	Het serveradres van uw containerregister.
query	properties.configuration.ingress.fqdn	Hiermee filtert u de uitvoer naar alleen de FQDN (Fully Qualified Domain Name) van de app.

Zodra deze opdracht is voltooid, wordt de URL voor uw nieuwe web-app geretourneerd.

Implementatie verifiëren

Kopieer de URL van de app naar een webbrowser. Zodra de container-app is gestart, wordt Hallo wereld! geretourneerd.

Omdat dit de eerste keer is dat de toepassing wordt geopend, kan het even duren voordat de app een antwoord retourneert.

Resources opschonen

Als u de Azure-resources die in deze zelfstudie zijn gemaakt niet gaat gebruiken, kunt u ze verwijderen met één opdracht. Voordat u de opdracht uitvoert, is er een volgende stap in deze reeks zelfstudies die laat zien hoe u wijzigingen aanbrengt in uw code en uw app bijwerkt in Azure.

Als u klaar bent en alle Azure-resources wilt verwijderen die in deze zelfstudie zijn gemaakt, verwijdert u de resourcegroep met de volgende opdracht.

az group delete --name aca-demo

Tip

Ondervindt u problemen? Laat het ons weten op GitHub door een probleem te openen in de Azure Container Apps-opslagplaats.

Volgende stappen

Ga vervolgens verder met het bijwerken van de container-app die u hebt gemaakt.

Een container-app bijwerken die is geïmplementeerd vanuit broncode