Samouczek: kompilowanie i wdrażanie z kodu źródłowego do usługi Azure Container Apps

W tym artykule pokazano, jak utworzyć i wdrożyć aplikację w usłudze Azure Container Apps z kodu źródłowego na maszynie w preferowanym języku programowania.

W tym samouczku wykonasz następujące elementy:

• Utwórz prostą aplikację internetową.
• Utwórz skojarzony plik Dockerfile dla aplikacji.
• Utwórz obraz na podstawie skompilowanego kodu i wypchnij go do rejestru kontenerów.
• Użyj tożsamości zarządzanej, aby bezpiecznie uzyskać dostęp do rejestru kontenerów.
• Wdróż kontener w usłudze Azure Container Apps.
• Wyświetl aplikację w przeglądarce, aby zweryfikować wdrożenie.

Wymagania wstępne

Do ukończenia tego projektu potrzebne są następujące elementy:

Wymaganie	Instrukcje
Konto platformy Azure	Jeśli go nie masz, utwórz bezpłatne konto. Aby kontynuować, musisz mieć uprawnienie Współautor lub Właściciel w subskrypcji platformy Azure. Aby uzyskać szczegółowe informacje, zobacz Przypisywanie ról platformy Azure przy użyciu witryny Azure Portal .
Interfejs wiersza polecenia platformy Azure	Zainstaluj interfejs wiersza polecenia platformy Azure lub uaktualnij go do najnowszej wersji. Interfejs wiersza polecenia dla deweloperów platformy Azure (azd polecenia) jest dostępny za pośrednictwem interfejsu wiersza polecenia platformy Azure.

W zależności od wybranego języka może być również konieczne zainstalowanie odpowiedniego środowiska uruchomieniowego, zestawu SDK i innych zależności.

C#

Zainstaluj zestaw .NET SDK.

Java

• Zainstaluj zestaw Java Development Kit.

• Zainstaluj narzędzie Apache Maven.

JavaScript

Zainstalowanie środowiska Node.js.

Python

Zainstaluj język Python.

Tworzenie aplikacji lokalnej

W poniższych krokach pokazano kod i zależności wymagane do utworzenia przykładowej aplikacji do wdrożenia w usłudze Azure Container Apps.

Uwaga

Jeśli chcesz użyć innego języka niż wymienione na liście, wprowadź następujący monit w preferowanym modelu sztucznej inteligencji.

Przed przesłaniem monitu zastąp <LANGUAGE> ciąg wybranym językiem.

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. Utwórz i uruchom kod źródłowy.

   C#

   Utwórz nowy projekt w języku C#.

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

   Przejdź do folderu MyAcaDemo .

   cd MyAcaDemo
   

   Otwórz Program.cs plik w edytorze kodu i zastąp zawartość następującym kodem.

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

   Implementowanie klasy za Program pomocą tego kodu powoduje utworzenie podstawy aplikacji internetowej. Następnie utwórz klasę odpowiedzialną za zwrócenie strony internetowej jako odpowiedzi.

   W tym samym folderze utwórz nowy plik o nazwie Startup.cs i wprowadź następujący kod.

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

   Teraz po wysłaniu żądania do aplikacji internetowej zostanie zwrócony tekst "Hello World!". Aby sprawdzić, czy kod działa poprawnie na komputerze lokalnym, skompiluj projekt w konfiguracji wydania.

   dotnet build -c Release
   

   Następnie uruchom aplikację, aby sprawdzić, czy kod został poprawnie zaimplementowany.

   dotnet run --configuration Release
   

   Java

   Utwórz nową aplikację Java, pobierając najpierw aplikację startową Spring Boot przy użyciu następującego polecenia.

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

   Jeśli nie masz zainstalowanego unzip polecenia, możesz go zainstalować teraz.

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

   Teraz możesz rozpakować pakiet do folderu o nazwie MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   Rozpakuj ten pakiet, tworząc zagnieżdżonym strukturę folderów, w której znajduje się folder o nazwie MyAcaDemo wewnątrz folderu zewnętrznego o nazwie MyAcaDemo.

   Użyj następującego polecenia, aby przejść do poprawnego folderu MyAcaDemo .

   cd MyAcaDemo/MyAcaDemo
   

   Otwórz ten folder w edytorze kodu, aby można było dodawać i edytować niektóre pliki.

   W folderze src/main/java/com/example/MyAcaDemo/ utwórz plik o nazwie MyAcaDemoController.java i wprowadź następujący kod.

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

   W folderze MyAcaDemo utwórz plik o nazwie pom.xml i dodaj następujący kod.

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

   Uruchom następujące polecenie, aby zweryfikować kompilacje projektu bez błędów.

   mvn clean package -DskipTests
   

   Po pomyślnym zakończeniu kompilacji uruchom następujące polecenie, aby upewnić się, że aplikacja działa poprawnie na maszynie.

   mvn spring-boot:run
   

   JavaScript

   Utwórz folder o nazwie MyAcaDemo do przechowywania plików dla aplikacji demonstracyjnej.

   mkdir MyAcaDemo
   

   Następnie przejdź do folderu MyAcaDemo .

   cd MyAcaDemo
   

   Użyj następującego polecenia, aby wygenerować podstawowe pliki dla aplikacji Node.js.

   npm init -y
   

   Otwórz ten folder w edytorze kodu i utwórz plik o nazwie index.js przy użyciu następującego kodu.

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

   Teraz możesz uruchomić następujące polecenie, aby upewnić się, że aplikacja działa poprawnie na maszynie.

   node index.js
   

   Python

   Utwórz folder o nazwie MyAcaDemo.

   mkdir MyAcaDemo
   

   Przejdź do folderu MyAcaDemo .

   cd MyAcaDemo
   

   Zainstaluj platformę Flask przy użyciu następującego polecenia.

   pip install flask
   

   Przykładowa aplikacja jest oparta na platformie Flask. Jest ona zainstalowana lokalnie, aby można było sprawdzić, czy aplikacja działa poprawnie na maszynie przed podjęciem próby wdrożenia jej w chmurze.

   Utwórz nowy plik o nazwie app.py i wprowadź następujący kod.

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

   Ten kod tworzy podstawowy serwer internetowy, który zwraca wartość Hello World!.

   W tym samym folderze utwórz nowy plik o nazwie requirements.txt i wprowadź następujący kod.

   Flask
   gunicorn
   

   Ten plik instruuje środowisko uruchomieniowe języka Python, aby używało platformy internetowej Platformy Flask i serwera internetowego gunicorn do hostowania przykładowej aplikacji.

   Uruchom następujące polecenie, aby sprawdzić, czy aplikacja działa poprawnie.

   python3 app.py
   

   Po sprawdzeniu, czy aplikacja działa zgodnie z oczekiwaniami, możesz zatrzymać serwer lokalny i przejść do tworzenia pliku Dockerfile, aby można było wdrożyć aplikację w usłudze Container Apps.

2. W folderze MyAcaDemo utwórz plik o nazwie Dockerfile i dodaj następującą zawartość.

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

   Teraz, gdy masz gotowy kod i plik Dockerfile, możesz wdrożyć aplikację w usłudze Azure Container Apps.

Tworzenie zasobów platformy Azure

1. Zaloguj się do platformy Azure z poziomu interfejsu wiersza polecenia przy użyciu następującego polecenia. Aby ukończyć proces uwierzytelniania, postępuj zgodnie ze wszystkimi monitami.

   az login
   

2. Zainstaluj lub zaktualizuj rozszerzenie usługi Azure Container Apps dla interfejsu wiersza polecenia platformy Azure.

   az extension add --name containerapp --upgrade
   

   Uwaga

   Jeśli podczas uruchamiania az containerapp poleceń wystąpią błędy dotyczące brakujących parametrów, upewnij się, że masz zainstalowaną najnowszą wersję rozszerzenia Azure Container Apps.

3. Po zakończeniu konfiguracji interfejsu wiersza polecenia platformy Azure możesz zdefiniować zestaw zmiennych środowiskowych.

   Przed uruchomieniem następującego polecenia przejrzyj podane wartości.

   Lokalizacja jest skonfigurowana jako Środkowe stany USA, ale jeśli wolisz, możesz zmienić lokalizację na najbliższą.

   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"
   

   Polecenie mydemoregistry$(openssl rand -hex 4) generuje losowy ciąg do użycia jako nazwę rejestru kontenerów. Nazwy rejestru muszą być globalnie unikatowe, dlatego ten ciąg pomaga zapewnić pomyślne uruchomienie poleceń.

4. Utwórz grupę zasobów, aby zorganizować usługi związane z wdrożeniem aplikacji kontenera.

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

5. Utwórz tożsamość zarządzaną przypisaną przez użytkownika i uzyskaj jej identyfikator za pomocą następujących poleceń.

   Najpierw utwórz tożsamość zarządzaną.

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

   Teraz ustaw identyfikator tożsamości na zmienną do późniejszego użycia.

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

6. Utwórz środowisko usługi Container Apps do hostowania aplikacji przy użyciu następującego polecenia.

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

7. Utwórz wystąpienie usługi Azure Container Registry (ACR) w grupie zasobów. Rejestr przechowuje obraz kontenera.

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

8. Przypisz tożsamość zarządzaną przypisaną przez użytkownika do wystąpienia rejestru kontenerów za pomocą następującego polecenia.

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

Kompilowanie i wypychanie obrazu do rejestru

Skompiluj i wypchnij obraz kontenera do wystąpienia rejestru kontenerów za pomocą następującego polecenia.

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

To polecenie stosuje tag helloworld do obrazu kontenera.

Tworzenie aplikacji kontenera

Utwórz aplikację kontenera za pomocą następującego polecenia.

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

To polecenie dodaje acrPull rolę do tożsamości zarządzanej przypisanej przez użytkownika, aby umożliwić ściąganie obrazów z rejestru kontenerów.

W poniższej tabeli opisano parametry używane przez to polecenie.

Parametr	Wartość	Opis
name	$CONTAINER_APP_NAME	Nazwa aplikacji kontenera.
resource-group	$RESOURCE_GROUP	Grupa zasobów, w której wdrożono aplikację kontenera.
environment	$ENVIRONMENT	Środowisko, w którym działa aplikacja kontenera.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	Obraz kontenera do wdrożenia, w tym nazwa rejestru i tag.
target-port	8080	Pasuje do portu, na który aplikacja nasłuchuje żądań.
ingress	external	Sprawia, że aplikacja kontenera jest dostępna z publicznego Internetu.
user-assigned	$IDENTITY_ID	Tożsamość zarządzana przypisana przez użytkownika dla aplikacji kontenera.
registry-identity	registry-identity	Tożsamość używana do uzyskiwania dostępu do rejestru kontenerów.
registry-server	$REGISTRY_NAME.azurecr.io	Adres serwera rejestru kontenerów.
query	properties.configuration.ingress.fqdn	Filtruje dane wyjściowe tylko do w pełni kwalifikowanej nazwy domeny (FQDN) aplikacji.

Po zakończeniu tego polecenia zwraca on adres URL nowej aplikacji internetowej.

Weryfikowanie wdrożenia

Skopiuj adres URL aplikacji do przeglądarki internetowej. Po uruchomieniu aplikacji kontenera zwraca wartość Hello World!.

Ponieważ jest to pierwszy raz, gdy aplikacja jest uzyskiwana, może upłynąć kilka chwil, aby aplikacja zwróciła odpowiedź.

Czyszczenie zasobów

Jeśli nie zamierzasz używać zasobów platformy Azure utworzonych w tym samouczku, możesz je usunąć za pomocą jednego polecenia. Przed uruchomieniem polecenia w tej serii samouczków zostanie wyświetlony kolejny krok pokazujący, jak wprowadzić zmiany w kodzie i zaktualizować aplikację na platformie Azure.

Jeśli wszystko będzie gotowe i chcesz usunąć wszystkie zasoby platformy Azure utworzone w tym samouczku, usuń grupę zasobów przy użyciu następującego polecenia.

az group delete --name aca-demo

Napiwek

Masz problemy? Poinformuj nas o usłudze GitHub, otwierając problem w repozytorium usługi Azure Container Apps.

Następne kroki

Następnie przejdź dalej, aby dowiedzieć się, jak zaktualizować utworzoną aplikację kontenera.

Aktualizowanie aplikacji kontenera wdrożonej z kodu źródłowego