Kurz: Sestavení a nasazení ze zdrojového kódu do Azure Container Apps

V tomto článku se dozvíte, jak sestavit a nasadit aplikaci do Azure Container Apps ze zdrojového kódu na svém počítači v preferovaném programovacím jazyce.

V tomto kurzu:

• Vytvořte jednoduchou webovou aplikaci.
• Vytvořte přidružený soubor Dockerfile pro vaši aplikaci.
• Vytvořte image z kompilovaného kódu a odešlete ji do registru kontejneru.
• Pomocí spravované identity můžete bezpečně přistupovat k registru kontejneru.
• Nasaďte kontejner do Azure Container Apps.
• Zobrazte si aplikaci v prohlížeči a ověřte nasazení.

Požadavky

K dokončení tohoto projektu potřebujete následující položky:

Požadavek	Pokyny
Účet Azure	Pokud ho nemáte, vytvořte si účet zdarma. K pokračování potřebujete oprávnění přispěvatele nebo vlastníka předplatného Azure. Podrobnosti najdete v tématu Přiřazení rolí Azure pomocí webu Azure Portal .
Azure CLI	Nainstalujte Azure CLI nebo upgradujte na nejnovější verzi. Azure Developer CLI (azd příkazy) je k dispozici prostřednictvím Azure CLI.

V závislosti na zvoleném jazyce možná budete muset nainstalovat také odpovídající modul runtime, sadu SDK a další závislosti.

C#

Nainstalujte sadu .NET SDK.

Java

• Nainstalujte sadu Java Development Kit.

• Nainstalujte Apache Maven.

JavaScript

Nainstalujte Node.js.

Python

Nainstalovat Python.

Vytvoření místní aplikace

Následující kroky ukazují kód a závislosti potřebné k sestavení ukázkové aplikace pro nasazení do Azure Container Apps.

Poznámka:

Pokud chcete použít jiný jazyk než ty uvedené, zadejte do preferovaného modelu AI následující výzvu.

Před odesláním výzvy nahraďte <LANGUAGE> zvoleným jazykem.

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. Vytvořte a spusťte zdrojový kód.

   C#

   Vytvořte nový projekt jazyka C#.

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

   Přejděte do složky MyAcaDemo .

   cd MyAcaDemo
   

   Otevřete Program.cs v editoru kódu a nahraďte obsah následujícím kódem.

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

   Program Implementace třídy s tímto kódem vytvoří základ webové aplikace. Dále vytvořte třídu odpovědnou za vrácení webové stránky jako odpovědi.

   Ve stejné složce vytvořte nový soubor s názvem Startup.cs a zadejte následující kód.

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

   Když se teď ve webové aplikaci vytvoří požadavek, vrátí se text "Hello World!". Pokud chcete ověřit, že váš kód běží správně na místním počítači, sestavte projekt v konfiguraci vydané verze.

   dotnet build -c Release
   

   Pak spusťte aplikaci a ověřte, že je váš kód implementovaný správně.

   dotnet run --configuration Release
   

   Java

   Vytvořte novou aplikaci Java tak, že nejprve načtete úvodní aplikaci Spring Boot pomocí následujícího příkazu.

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

   Pokud nemáte unzip příkaz nainstalovaný, můžete ho nainstalovat.

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

   Teď můžete balíček rozbalit do složky s názvem MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   Když tento balíček rozbalíte, vytvoří vnořenou strukturu složek, ve které se nachází složka s názvem MyAcaDemo uvnitř vnější složky s názvem MyAcaDemo.

   Pomocí následujícího příkazu přejděte do správné složky MyAcaDemo .

   cd MyAcaDemo/MyAcaDemo
   

   Otevřete tuto složku v editoru kódu, abyste mohli přidat a upravit některé soubory.

   src/main/java/com/example/MyAcaDemo/ Ve složce vytvořte soubor s názvem MyAcaDemoController.java a zadejte následující kód.

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

   Ve složce MyAcaDemo vytvořte soubor s názvem pom.xml a přidejte následující kód.

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

   Spuštěním následujícího příkazu ověřte sestavení projektu bez chyb.

   mvn clean package -DskipTests
   

   Po úspěšném sestavení spusťte následující příkaz, abyste zajistili, že aplikace na vašem počítači běží správně.

   mvn spring-boot:run
   

   JavaScript

   Vytvořte složku s názvem MyAcaDemo pro uložení souborů pro ukázkovou aplikaci.

   mkdir MyAcaDemo
   

   V dalším kroku přejděte do složky MyAcaDemo .

   cd MyAcaDemo
   

   Pomocí následujícího příkazu vygenerujte základní soubory pro Node.js aplikaci.

   npm init -y
   

   Otevřete tuto složku v editoru kódu a vytvořte soubor s názvem index.js s následujícím kódem.

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

   Teď můžete spustit následující příkaz, abyste zajistili, že aplikace na vašem počítači běží správně.

   node index.js
   

   Python

   Vytvořte složku s názvem MyAcaDemo.

   mkdir MyAcaDemo
   

   Přejděte do složky MyAcaDemo .

   cd MyAcaDemo
   

   Nainstalujte Flask pomocí následujícího příkazu.

   pip install flask
   

   Ukázková aplikace je založená na rozhraní Flask. Potřebujete ho nainstalovat místně, abyste mohli ověřit, jestli je aplikace na vašem počítači správně spuštěná, než se pokusíte ji nasadit do cloudu.

   Vytvořte nový soubor s názvem app.py a zadejte následující kód.

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

   Tento kód vytvoří základní webový server, který vrátí hello World!.

   Ve stejné složce vytvořte nový soubor s názvem requirements.txt a zadejte následující kód.

   Flask
   gunicorn
   

   Tento soubor dává modulu runtime Pythonu pokyn, aby k hostování ukázkové aplikace používal webový server Flask a webový server gunicorn .

   Spuštěním následujícího příkazu ověřte, že aplikace funguje správně.

   python3 app.py
   

   Jakmile ověříte, že aplikace funguje podle očekávání, můžete zastavit místní server a přejít k vytvoření souboru Dockerfile, abyste mohli aplikaci nasadit do Container Apps.

2. Ve složce MyAcaDemo vytvořte soubor s názvem Dockerfile a přidejte následující obsah.

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

   Teď, když máte kód a soubor Dockerfile připravený, můžete aplikaci nasadit do Azure Container Apps.

Vytvoření zdrojů Azure

1. Přihlaste se k Azure z rozhraní příkazového řádku pomocí následujícího příkazu. Pokud chcete dokončit proces ověřování, nezapomeňte postupovat podle všech výzev.

   az login
   

2. Nainstalujte nebo aktualizujte rozšíření Azure Container Apps pro Azure CLI.

   az extension add --name containerapp --upgrade
   

   Poznámka:

   Pokud se při spouštění az containerapp příkazů zobrazí chyby týkající se chybějících parametrů, ujistěte se, že máte nainstalovanou nejnovější verzi rozšíření Azure Container Apps.

3. Teď, když je nastavení Azure CLI hotové, můžete definovat sadu proměnných prostředí.

   Před spuštěním následujícího příkazu zkontrolujte zadané hodnoty.

   Umístění je nakonfigurované jako USA – střed, ale pokud chcete, můžete přejít na nejbližší umístění.

   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"
   

   Příkaz mydemoregistry$(openssl rand -hex 4) vygeneruje náhodný řetězec, který se použije jako název registru kontejneru. Názvy registru musí být globálně jedinečné, takže tento řetězec pomáhá zajistit úspěšné spuštění příkazů.

4. Vytvořte skupinu prostředků pro uspořádání služeb souvisejících s nasazením aplikace kontejneru.

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

5. Vytvořte spravovanou identitu přiřazenou uživatelem a získejte její ID pomocí následujících příkazů.

   Nejprve vytvořte spravovanou identitu.

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

   Teď nastavte identifikátor identity na proměnnou pro pozdější použití.

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

6. Vytvořte prostředí Container Apps pro hostování aplikace pomocí následujícího příkazu.

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

7. Ve skupině prostředků vytvořte instanci služby Azure Container Registry (ACR). Registr ukládá image kontejneru.

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

8. Pomocí následujícího příkazu přiřaďte spravovanou identitu přiřazenou uživatelem k instanci registru kontejneru.

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

Sestavení a nasdílení image do registru

Pomocí následujícího příkazu sestavte a nasdílejte image kontejneru do instance registru kontejneru.

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

Tento příkaz použije značku helloworld na image kontejneru.

Vytvoření kontejnerové aplikace

Pomocí následujícího příkazu vytvořte aplikaci kontejneru.

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

Tento příkaz přidá acrPull roli do spravované identity přiřazené uživatelem, aby mohl načíst image z registru kontejneru.

Následující tabulka popisuje parametry používané tímto příkazem.

Parametr	Hodnota	Popis
name	$CONTAINER_APP_NAME	Název vaší aplikace kontejneru.
resource-group	$RESOURCE_GROUP	Skupina prostředků, ve které je vaše aplikace kontejneru nasazená.
environment	$ENVIRONMENT	Prostředí, ve kterém vaše aplikace kontejneru běží.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	Image kontejneru, která se má nasadit, včetně názvu a značky registru.
target-port	8080	Odpovídá portu, na který vaše aplikace naslouchá žádostem.
ingress	external	Zpřístupňuje vaše aplikace kontejneru z veřejného internetu.
user-assigned	$IDENTITY_ID	Spravovaná identita přiřazená uživatelem pro vaši aplikaci kontejneru.
registry-identity	registry-identity	Identita použitá pro přístup k registru kontejneru.
registry-server	$REGISTRY_NAME.azurecr.io	Adresa serveru vašeho registru kontejneru.
query	properties.configuration.ingress.fqdn	Filtruje výstup jenom na plně kvalifikovaný název domény (FQDN) aplikace.

Po dokončení tohoto příkazu vrátí adresu URL nové webové aplikace.

Ověření nasazení

Zkopírujte adresu URL aplikace do webového prohlížeče. Jakmile se aplikace kontejneru spustí, vrátí hello World!.

Vzhledem k tomu, že k aplikaci přistupujete poprvé, může chvíli trvat, než aplikace vrátí odpověď.

Vyčištění prostředků

Pokud nebudete používat prostředky Azure vytvořené v tomto kurzu, můžete je odebrat jediným příkazem. Před spuštěním příkazu je v této sérii kurzů další krok, který ukazuje, jak provádět změny kódu a aktualizovat aplikaci v Azure.

Pokud jste hotovi a chcete odebrat všechny prostředky Azure vytvořené v tomto kurzu, odstraňte skupinu prostředků pomocí následujícího příkazu.

az group delete --name aca-demo

Tip

Máte problémy? Dejte nám vědět na GitHubu otevřením problému v úložišti Azure Container Apps.

Další kroky

Dále pokračujte a zjistěte, jak aktualizovat aplikaci kontejneru, kterou jste vytvořili.

Aktualizace aplikace kontejneru nasazené ze zdrojového kódu