Tutoriel : Générer et déployer à partir du code source sur Azure Container Apps

Cet article vous montre comment générer et déployer une application sur Azure Container Apps à partir du code source sur votre ordinateur dans votre langage de programmation préféré.

Dans ce tutoriel, vous allez :

• Créez une application web simple.
• Créez un fichier Dockerfile associé pour votre application.
• Créez une image à partir du code compilé et l’envoyez (push) à un registre de conteneurs.
• Utilisez une identité managée pour accéder de façon sécurisée à votre registre de conteneurs.
• Déployez votre conteneur sur Azure Container Apps.
• Affichez votre application dans un navigateur pour vérifier le déploiement.

Prérequis

Pour mener à bien ce projet, vous avez besoin des éléments suivants :

Condition requise	Instructions
Compte Azure	Si vous n’en avez pas un, créez un compte gratuitement. Vous avez besoin de l’autorisation Contributeur ou Propriétaire sur l’abonnement Azure pour continuer. Pour plus d’informations, consultez Attribuer des rôles Azure à l’aide du portail Azure.
Azure CLI	Installez Azure CLI ou procédez à une mise à niveau vers la dernière version. Azure Developer CLI (commandes azd) est disponible via Azure CLI.

En fonction de votre choix de langage, vous devrez peut-être également installer le runtime, le SDK et autres dépendances correspondants.

C#

Installez le Kit de développement logiciel (SDK) pour .NET.

Java

• Installer le kit de développement Java.

• Installez Apache Maven.

JavaScript

Installez Node.js.

Python

Installez Python.

Créer l’application locale

Les étapes suivantes montrent le code et les dépendances nécessaires pour générer un exemple d’application à déployer sur Azure Container Apps.

Remarque

Si vous souhaitez utiliser un autre langage que ceux qui sont répertoriés, entrez le prompt suivant dans le modèle IA de votre choix.

Avant d’envoyer le prompt, remplacez <LANGUAGE> par le langage que vous voulez.

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. Créez et exécutez votre code source.

   C#

   Créez un nouveau projet C#.

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

   Accédez au dossier MyAcaDemo.

   cd MyAcaDemo
   

   Ouvrez Program.cs dans un éditeur de code et remplacez le contenu par le code suivant.

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

   L’implémentation de la classe Program avec ce code crée la base d’une application web. Ensuite, créez une classe chargée de retourner une page web comme réponse.

   Dans le même dossier, créez un fichier nommé Startup.cs et entrez le code suivant.

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

   À présent, lorsqu’une demande est adressée à votre application web, le texte « Hello World! » est retourné. Pour vérifier que votre code s’exécute correctement sur votre ordinateur local, générez votre projet dans la configuration Release.

   dotnet build -c Release
   

   Ensuite, exécutez votre application pour vérifier que votre code est implémenté correctement.

   dotnet run --configuration Release
   

   Java

   Créez une application Java en récupérant d’abord l’application de départ Spring Boot à l’aide de la commande suivante.

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

   Si vous n’avez pas la commande unzip installée, vous pouvez l’installer maintenant.

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

   Vous pouvez maintenant décompresser le package dans un dossier appelé MyAcaDemo.

   unzip MyAcaDemo.zip -d MyAcaDemo
   

   Lorsque vous décompressez ce package, celui-ci crée une structure de dossiers imbriqués où un dossier appelé MyAcaDemo réside dans un dossier externe appelé MyAcaDemo.

   Utilisez la commande suivante pour passer au dossier MyAcaDemo approprié.

   cd MyAcaDemo/MyAcaDemo
   

   Ouvrez ce dossier dans un éditeur de code pour pouvoir ajouter et modifier certains fichiers.

   Dans le dossier src/main/java/com/example/MyAcaDemo/, créez un fichier appelé MyAcaDemoController.java et entrez le code suivant.

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

   Dans le dossier MyAcaDemo, créez un fichier appelé pom.xml et ajoutez le code suivant.

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

   Exécutez la commande suivante pour vérifier que votre projet est généré sans erreur.

   mvn clean package -DskipTests
   

   Une fois que vous avez une build réussie, exécutez la commande suivante pour vous assurer que l’application s’exécute correctement sur votre ordinateur.

   mvn spring-boot:run
   

   JavaScript

   Créez un dossier appelé MyAcaDemo pour contenir les fichiers de l’application de démonstration.

   mkdir MyAcaDemo
   

   Ensuite, accédez au dossier MyAcaDemo.

   cd MyAcaDemo
   

   Utilisez la commande suivante pour générer les fichiers de base d’une application Node.js.

   npm init -y
   

   Ouvrez ce dossier dans un éditeur de code et créez un fichier appelé index.js avec le code suivant.

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

   Vous pouvez maintenant exécuter la commande suivante pour vous assurer que l’application s’exécute correctement sur votre ordinateur.

   node index.js
   

   Python

   Créez un dossier appelé MyAcaDemo.

   mkdir MyAcaDemo
   

   Accédez au dossier MyAcaDemo.

   cd MyAcaDemo
   

   Installez Flask à l’aide de la commande suivante.

   pip install flask
   

   L’exemple d’application est basé sur le framework Flask. Vous devez l’installer localement pour pouvoir vérifier que votre application s’exécute correctement sur votre ordinateur avant de tenter de la déployer dans le cloud.

   Créez un fichier appelé app.py et entrez le code suivant.

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

   Ce code crée un serveur web de base qui retourne Hello World!.

   Dans le même dossier, créez un fichier nommé requirements.txt et entrez le code suivant.

   Flask
   gunicorn
   

   Ce fichier indique au runtime Python d’utiliser le framework web Flask et le serveur web gunicorn pour héberger l’exemple d’application.

   Exécutez la commande suivante pour vérifier que l’application fonctionne.

   python3 app.py
   

   Une fois que vous avez vérifié que l’application fonctionne comme prévu, vous pouvez arrêter le serveur local et passer à la création d’un fichier Dockerfile afin de pouvoir déployer l’application sur Container Apps.

2. Dans le dossier MyAcaDemo, créez un fichier appelé Dockerfile et ajoutez le contenu suivant.

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

   Maintenant que vous avez votre code et un fichier Dockerfile prêt, vous pouvez déployer votre application sur Azure Container Apps.

Créer des ressources Azure

1. Connectez-vous à Azure depuis l’interface de ligne de commande en utilisant la commande suivante. Pour effectuer le processus d’authentification, veillez à suivre toutes les invites.

   az login
   

2. Installez ou mettez à jour l’extension Azure Container Apps pour l’interface Azure CLI.

   az extension add --name containerapp --upgrade
   

   Remarque

   Si vous recevez des erreurs concernant des paramètres manquants lorsque vous exécutez des commandes az containerapp, vérifiez que la dernière version de l’extension Azure Container Apps est installée.

3. À présent que votre configuration Azure CLI est terminée, vous pouvez définir un ensemble de variables d’environnement.

   Avant d’exécuter la commande suivante, passez en revue les valeurs fournies.

   La région est configurée avec USA Centre, mais vous pouvez en définir une plus proche si vous préférez.

   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"
   

   La commande mydemoregistry$(openssl rand -hex 4) génère une chaîne aléatoire à utiliser comme nom de registre de conteneurs. Les noms de registre doivent être globalement uniques, donc cette chaîne permet de s’assurer que vos commandes s’exécutent correctement.

4. Créez un groupe de ressources pour organiser les services liés au déploiement de votre application de conteneur.

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

5. Créez une identité managée affectée par l’utilisateur et obtenez son ID en utilisant les commandes suivantes.

   Créez d’abord l’identité managée.

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

   Maintenant, définissez l’identificateur d’identité dans une variable pour l’utiliser ultérieurement.

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

6. Créez un environnement Container Apps pour héberger votre application à l’aide de la commande suivante.

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

7. Créez une instance Azure Container Registry (ACR) dans votre groupe de ressources. Le registre stocke votre image conteneur.

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

8. Attribuez votre identité managée affectée par l’utilisateur à votre instance de registre de conteneurs avec la commande suivante.

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

Générer et envoyer (push) l’image à un registre

Générez et envoyez (push) votre image conteneur à votre instance de registre de conteneurs avec la commande suivante.

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

Cette commande applique la balise helloworld à votre image conteneur.

Créer votre application conteneur

Créez votre application conteneur avec la commande suivante.

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

Cette commande ajoute le rôle acrPull à votre identité managée affectée par l’utilisateur afin qu’elle puisse extraire des images de votre registre de conteneurs.

Le tableau suivant décrit les paramètres utilisés par cette commande.

Paramètre	active	Description
name	$CONTAINER_APP_NAME	Nom de votre application conteneur.
resource-group	$RESOURCE_GROUP	Groupe de ressources dans lequel votre application conteneur est déployée.
environment	$ENVIRONMENT	Environnement dans lequel s’exécute votre application conteneur.
image	$REGISTRY_NAME".azurecr.io/"$CONTAINER_APP_NAME":helloworld"	Image conteneur à déployer, notamment le nom et l’étiquette du registre.
target-port	8080	Correspond au port que votre application écoute pour les demandes.
ingress	external	Rend votre application conteneur accessible à partir de l’Internet public.
user-assigned	$IDENTITY_ID	Identité managée affectée par l’utilisateur pour votre application conteneur.
registry-identity	registry-identity	Identité utilisée pour accéder au registre de conteneurs.
registry-server	$REGISTRY_NAME.azurecr.io	Adresse du serveur de votre registre de conteneurs.
query	properties.configuration.ingress.fqdn	Filtre la sortie sur le nom de domaine complet (FQDN) de l’application uniquement.

Une fois cette commande terminée, elle retourne l’URL de votre nouvelle application web.

Vérifier le déploiement

Copiez l’URL de l’application dans un navigateur web. Une fois l’application conteneur démarrée, elle retourne Hello World!.

Étant donné qu’il s’agit du premier accès à l’application, celle-ci peut prendre un peu de temps avant de retourner une réponse.

Nettoyer les ressources

Si vous n’allez pas utiliser les ressources Azure créées dans ce tutoriel, vous pouvez les supprimer avec une seule commande. Avant d’exécuter la commande, il existe une autre étape dans cette série de tutoriels qui vous montre comment apporter des modifications à votre code et mettre à jour votre application dans Azure.

Si vous avez terminé et souhaitez supprimer toutes les ressources Azure créées dans ce tutoriel, supprimez le groupe de ressources avec la commande suivante.

az group delete --name aca-demo

Conseil

Vous rencontrez des problèmes ? Faites-le nous savoir sur GitHub en ouvrant un problème dans le dépôt Azure Container Apps.

Étapes suivantes

Poursuivez votre apprentissage en découvrant comment mettre à jour l’application conteneur que vous avez créée.

Mettre à jour une application conteneur déployée à partir du code source