Tutorial: Erstellen und Bereitstellen über Quellcode in Azure Container Apps

In diesem Artikel erfahren Sie, wie Sie über Quellcode auf Ihrem Computer in Ihrer bevorzugten Programmiersprache eine Anwendung in Azure Container Apps erstellen und bereitstellen.

In diesem Tutorial führen Sie Folgendes durch:

Erstellen einer einfachen Webanwendung
Erstellen eines zugehörigen Dockerfile für Ihre App
Erstellen eines Images aus dem kompilierten Code und Pushen an eine Containerregistrierung
Verwenden einer verwalteten Identität für den sicheren Zugriff auf Ihre Containerregistrierung
Bereitstellen Ihres Containers in Azure Container Apps
Anzeigen der App in einem Browser, um die Bereitstellung zu überprüfen

Voraussetzungen

Zum Abschließen dieses Projekts benötigen Sie die folgenden Elemente:

Anforderung	Anweisungen
Azure-Konto	Erstellen Sie ein kostenloses Konto, falls Sie keines besitzen. Sie benötigen die Berechtigung Mitwirkender oder Besitzer für das Azure-Abonnement, um den Vorgang fortzusetzen. Weitere Einzelheiten finden Sie unter Zuweisen von Azure-Rollen über das Azure-Portal.
Azure-Befehlszeilenschnittstelle	Installieren Sie die Azure-Befehlszeilenschnittstelle, oder upgraden Sie sie auf die neueste Version. Azure Developer CLI (`azd`-Befehle) ist über die Azure CLI verfügbar.

Je nach ausgewählter Sprache müssen Sie möglicherweise auch die entsprechende Laufzeit, das SDK und andere Abhängigkeiten installieren.

Installieren Sie das .NET SDK.

Erstellen der lokalen Anwendung

Die folgenden Schritte zeigen den Code und die Abhängigkeiten, die zum Erstellen einer Beispielanwendung zum Bereitstellen in Azure Container Apps erforderlich sind.

Hinweis

Wenn Sie eine andere Sprache als die aufgeführten verwenden möchten, geben Sie den folgenden Prompt in Ihr bevorzugtes KI-Modell ein.

Bevor Sie den Prompt übermitteln, ersetzen Sie <LANGUAGE> durch Ihre gewünschte Sprache.

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.

Erstellen Sie den Quellcode, und führen Sie ihn aus.
- C#
- Java
- JavaScript
- Python
Erstellen Sie ein neues C#-Projekt.
```
dotnet new webapp --name MyAcaDemo --language C#
```
Wechseln Sie in den Ordner MyAcaDemo.
```
cd MyAcaDemo
```
Öffnen Sie Program.cs in einem Code-Editor, und ersetzen Sie den Inhalt durch folgenden 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");
            });
}
```
Durch die Implementierung der Program-Klasse mit diesem Code wird die Grundlage einer Webanwendung erstellt. Erstellen Sie als Nächstes eine Klasse, die für die Rückgabe einer Webseite als Antwort verantwortlich ist.

Erstellen Sie im selben Ordner eine neue Datei mit dem Namen Startup.cs, und geben Sie den folgenden Code ein:
```
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!");
            });
        });
    }
}
```
Wenn nun eine Anforderung an Ihre Webanwendung gesendet wird, wird der Text „Hallo Welt!“ zurückgegeben. Um zu überprüfen, ob der Code auf dem lokalen Computer ordnungsgemäß ausgeführt wird, erstellen Sie Ihr Projekt in der Releasekonfiguration.
```
dotnet build -c Release
```
Führen Sie als Nächstes die Anwendung aus, um zu überprüfen, ob der Code ordnungsgemäß implementiert ist.
```
dotnet run --configuration Release
```
Erstellen Sie eine neue Java-Anwendung, indem Sie zuerst die Spring Boot Starter-Anwendung mit dem folgenden Befehl abrufen:
```
curl https://start.spring.io/starter.zip -d dependencies=web -d name=MyAcaDemo -d artifactId=MyAcaDemo -d baseDir=MyAcaDemo -o MyAcaDemo.zip
```
Falls der unzip-Befehl nicht installiert ist, können Sie ihn nun installieren.
```
sudo apt-get update && sudo apt-get install unzip
```
Jetzt können Sie das Paket in einem Ordner mit dem Namen MyAcaDemo entzippen.
```
unzip MyAcaDemo.zip -d MyAcaDemo
```
Beim Entpacken dieses Pakets wird eine geschachtelte Ordnerstruktur erstellt, in der ein Ordner mit dem Namen MyAcaDemo in einem äußeren Ordner namens MyAcaDemo enthalten ist.

Verwenden Sie den folgenden Befehl, um in den richtigen Ordner MyAcaDemo zu wechseln.
```
cd MyAcaDemo/MyAcaDemo
```
Öffnen Sie diesen Ordner in einem Code-Editor, damit Sie einige Dateien hinzufügen und bearbeiten können.

Erstellen Sie im Ordner src/main/java/com/example/MyAcaDemo/ eine Datei mit dem Namen MyAcaDemoController.java, und geben Sie den folgenden Code ein:
```
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!";
    }
}
```
Erstellen Sie im Ordner MyAcaDemo eine Datei mit dem Namen pom.xml, und fügen Sie den folgenden Code hinzu:
```
<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/> 
    </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>
```
Führen Sie den folgenden Befehl aus, um sicherzustellen, dass Ihr Projekt ohne Fehler erstellt wird.
```
mvn clean package -DskipTests
```
Nachdem Sie einen erfolgreichen Build erstellt haben, führen Sie den folgenden Befehl aus, um sicherzustellen, dass die Anwendung auf Ihrem Computer ordnungsgemäß ausgeführt wird.
```
mvn spring-boot:run
```
Erstellen Sie einen Ordner mit dem Namen MyAcaDemo, um die Dateien für die Demoanwendung zu speichern.
```
mkdir MyAcaDemo
```
Wechseln Sie als Nächstes in den Ordner MyAcaDemo.
```
cd MyAcaDemo
```
Verwenden Sie den folgenden Befehl, um die grundlegenden Dateien für eine Node.js-Anwendung zu generieren.
```
npm init -y
```
Öffnen Sie diesen Ordner in einem Code-Editor, und erstellen Sie eine Datei namens index.js mit dem folgenden 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/');
});
```
Sie können nun den folgenden Befehl ausführen, um sicherzustellen, dass die Anwendung auf Ihrem Computer ordnungsgemäß ausgeführt wird:
```
node index.js
```
Erstellen Sie einen Ordner mit dem Namen MyAcaDemo.
```
mkdir MyAcaDemo
```
Wechseln Sie in den Ordner MyAcaDemo.
```
cd MyAcaDemo
```
Installieren Sie Flask mithilfe des folgenden Befehls:
```
pip install flask
```
Die Beispielanwendung basiert auf dem Flask-Framework. Es muss lokal installiert sein, damit Sie überprüfen können, ob Ihre App auf Ihrem Computer ordnungsgemäß ausgeführt wird, bevor Sie versuchen, sie in der Cloud bereitzustellen.

Erstellen Sie eine neue Datei mit dem Namen app.py, und geben Sie den folgenden Code ein:
```
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return '<html>Hello World!</html>'

if __name__ == '__main__':
    app.run()
```
Dieser Code erstellt einen einfachen Webserver, der Hallo Welt! zurückgibt.

Erstellen Sie im selben Ordner eine neue Datei mit dem Namen requirements.txt, und geben Sie den folgenden Code ein:
```
Flask
gunicorn
```
Diese Datei weist die Python-Runtime an, das Flask-Webframework und den gunicorn-Webserver zum Hosten der Beispielanwendung zu verwenden.

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Anwendung ordnungsgemäß funktioniert:
```
python3 app.py
```
Nachdem Sie überprüft haben, ob die Anwendung wie erwartet funktioniert, können Sie den lokalen Server beenden und mit dem Erstellen eines Dockerfile fortfahren, damit Sie die App in Container Apps bereitstellen können.

Erstellen Sie im Ordner MyAcaDemo eine Datei mit dem Namen Dockerfile, und fügen Sie den folgenden Inhalt hinzu:

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

Nachdem der Code und das Dockerfile vorbereitet wurden, können Sie Ihre App in Azure Container Apps bereitstellen.

Erstellen von Azure-Ressourcen

Melden Sie sich mithilfe des folgenden Befehls über die CLI bei Azure an. Achten Sie darauf, alle Eingabeaufforderungen zu befolgen, um den Authentifizierungsprozess abzuschließen.
```
az login
```
Installieren oder aktualisieren Sie die Azure Container Apps-Erweiterung für die Azure CLI.
```
az extension add --name containerapp --upgrade
```
Hinweis

Wenn Sie beim Ausführen von az containerapp-Befehlen Fehlermeldungen im Zusammenhang mit fehlenden Parametern erhalten, stellen Sie sicher, dass Sie die aktuelle Version der Erweiterung für Azure Container Apps installiert haben.
Nachdem die Einrichtung der Azure CLI abgeschlossen ist, können Sie nun die Umgebungsvariablen definieren.

Bevor Sie den folgenden Befehl ausführen, überprüfen Sie die angegebenen Werte.

Für den Standort wurde USA, Mitte konfiguriert, Sie können diesen aber bei Bedarf in einen Standort in Ihrer Nähe ändern.
```
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"
```
Der Befehl mydemoregistry$(openssl rand -hex 4) generiert eine zufällige Zeichenfolge, die als Containerregistrierungsname verwendet wird. Registrierungsnamen müssen global eindeutig sein, sodass diese Zeichenfolge zur erfolgreichen Ausführung Ihrer Befehle beiträgt.
Erstellen Sie eine Ressourcengruppe, um die Dienste im Zusammenhang mit der Bereitstellung Ihrer Container-App zu organisieren.
```
az group create \
  --name $RESOURCE_GROUP \
  --location $LOCATION \
  --output none
```
Erstellen Sie eine benutzerseitig zugewiesene verwaltete Identität, und rufen Sie ihre ID mit den folgenden Befehlen ab.

Erstellen Sie zunächst die verwaltete Identität.
```
az identity create \
    --name $IDENTITY_NAME \
    --resource-group $RESOURCE_GROUP \
    --output none
```
Legen Sie nun den Identitätsbezeichner zur späteren Verwendung auf eine Variable fest.
```
IDENTITY_ID=$(az identity show \
  --name $IDENTITY_NAME \
  --resource-group $RESOURCE_GROUP \
  --query id \
  --output tsv)
```

Erstellen Sie mit dem folgenden Befehl eine Container Apps-Umgebung zum Hosten Ihrer App:

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

Erstellen Sie eine Azure Container Registry-Instanz (ACR) in Ihrer Ressourcengruppe. Die Registrierung speichert Ihr Containerimage.
```
az acr create \
  --resource-group $RESOURCE_GROUP \
  --name $REGISTRY_NAME \
  --sku Basic \
  --output none
```

Weisen Sie mit dem folgenden Befehl Ihrer Containerregistrierungsinstanz die benutzerseitig zugewiesene verwaltete Identität zu:

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

Erstellen des Images und Pushen des Images an eine Registrierung

Mit dem folgenden Befehl können Sie das Containerimage erstellen und an Ihre Containerregistrierungsinstanz pushen:

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

Dieser Befehl wendet das Tag helloworld auf Ihr Containerimage an.

Erstellen Ihrer Container-App

Erstellen Sie Ihre Container App mit dem folgenden Befehl:

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

Mit diesem Befehl wird der benutzerseitig zugewiesenen verwalteten Identität die Rolle acrPull hinzugefügt, sodass Images aus der Containerregistrierung gepullt werden können.

In der folgenden Tabelle sind die Parameter beschrieben, die von diesem Befehl verwendet werden.

Parameter	Wert	Beschreibung
`name`	`$CONTAINER_APP_NAME`	Der Name Ihrer Container-App
`resource-group`	`$RESOURCE_GROUP`	Die Ressourcengruppe, in der die Container-App bereitgestellt wird
`environment`	`$ENVIRONMENT`	Die Umgebung, in der Ihre Container-App ausgeführt wird
`image`	`$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"`	Das bereitzustellende Containerimage, einschließlich des Registrierungsnamens und -tags
`target-port`	`8080`	Entspricht dem Port, an dem Ihre App auf Anforderungen lauscht.
`ingress`	`external`	Macht Ihre Container-App über das öffentliche Internet zugänglich.
`user-assigned`	`$IDENTITY_ID`	Die benutzerseitig zugewiesene verwaltete Identität für Ihre Container-App
`registry-identity`	`registry-identity`	Die zum Zugreifen auf die Containerregistrierung verwendete Identität
`registry-server`	`$REGISTRY_NAME.azurecr.io`	Die Serveradresse Ihrer Containerregistrierung
`query`	`properties.configuration.ingress.fqdn`	Filtert die Ausgabe nur auf den vollqualifizierten Domänennamen (Fully Qualified Domain Name, FQDN) der App.

Sobald dieser Befehl abgeschlossen ist, wird die URL für Ihre neue Web-App zurückgegeben.

Überprüfen der Bereitstellung

Kopieren Sie die App-URL in einen Webbrowser. Nachdem die Container-App gestartet wurde, gibt sie Hallo Welt! zurück.

Da die Anwendung zum ersten Mal aufgerufen wird, kann es einige Minuten dauern, bis die App eine Antwort zurückgibt.

Bereinigen von Ressourcen

Wenn Sie die in diesem Tutorial erstellten Azure-Ressourcen nicht mehr verwenden werden, können Sie sie mit einem einzigen Befehl entfernen. Bevor Sie den Befehl ausführen, gibt es einen nächsten Schritt in dieser Tutorialreihe, der zeigt, wie Sie Änderungen am Code vornehmen und Ihre App in Azure aktualisieren.

Wenn Sie fertig sind und alle in diesem Tutorial erstellten Azure-Ressourcen entfernen möchten, löschen Sie die Ressourcengruppe mit dem folgenden Befehl:

az group delete --name aca-demo

Tipp

Treten Probleme auf? Informieren Sie uns über GitHub, indem Sie ein Problem im Azure Container Apps-Repository öffnen.

Nächste Schritte

Lesen Sie als Nächstes, wie Sie die von Ihnen erstellte Container-App aktualisieren:

Aktualisieren einer über Quellcode bereitgestellten Container-App

Feedback

War diese Seite hilfreich?

Last updated on 2025-03-03