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.

Installeer de .NET SDK.

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.

Maak en voer de broncode uit.

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

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

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

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.

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

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

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

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

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

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

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)

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

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

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

Feedback

Is deze pagina nuttig?

Last updated on 2025-02-25