Le but de cette article est de vous montrer comment conteneuriser une API web avec ASP.NET Core.

Prérequis :

• Visual Studio Code
• C# extension pour VSCode
• SDK .NET 7.0
• Docker Desktop
• Docker extension pour VSCode

Création du projet API :

1 . Créer un nouveau projet API web avec Visual Studio Code

• Dans le répertoire où vous souhaitez créer votre projet, faites un clic droit et “Ouvrir dans le terminal”.
• Dans le terminal, exécuter les commandes suivantes :

dotnet new webapi --no-https -o MyWebApi  //Création d'un projet nommé "MyWebApi"

cd MyWebApi  //Se déplacer dans le repertoire du projet

dotnet add package Microsoft.EntityFrameworkCore.InMemory  //Ajout du package NuGet pour simuler une base de données en mémoire

code -r ../MyWebApi  //Ouvrir le projet dans Visual Studio Code

/!\ Il est important de créer le projet sans HTTPS car lors de la conteneurisation, il faut que le conteneur docker créer soit en HTTP /!\

2 . Tester l’application

• Dans le terminal VSCode (CTRL + Shift + ù), exécuter la commande suivante :

dotnet run  //Lancer l'application

• Dans un navigateur, entrer l’url suivant : http://localhost:<port>/weatherforecast

=> le <port> est visible dans le terminal à la suite de la commande “dotnet run”

• Vous devriez avoir un résultat similaire qui s’affiche :

• Ensuite dans le navigateur entrer l’url suivant : http://localhost:<port>/swagger/index.html

=> l’interface Swagger s’affiche

• Dans l’interface Swagger, cliquer sur :

– GET /weatherforecast

– Try it out

– Execute

Vous devriez avoir le même résultat que précédemment :

    [
       {
          "date":"2022-12-15",
          "temperatureC":-19,
          "temperatureF":-2,
          "summary":"Balmy"
       },
       {
          "date":"2022-12-16",
          "temperatureC":-20,
          "temperatureF":-3,
          "summary":"Chilly"
       },
       {
          "date":"2022-12-17",
          "temperatureC":24,
          "temperatureF":75,
          "summary":"Balmy"
       },
       {
          "date":"2022-12-18",
          "temperatureC":31,
          "temperatureF":87,
          "summary":"Chilly"
       },
       {
          "date":"2022-12-19",
          "temperatureC":7,
          "temperatureF":44,
          "summary":"Sweltering"
       }
   ]

Les erreurs que vous pouvez rencontrer à cette étape :

Si vous allez sur la page http://localhost:<port > , une page d’erreur 404 doit s’afficher. C’est normal les url à saisir sont http://localhost:<port>/weatherforecast ou http://localhost:<port>/swagger/index.html.

Si vous souhaitez complexifier votre API, vous pouvez suivre le tutoriel officiel de Microsoft à partir de cette partie : https://learn.microsoft.com/fr-fr/aspnet/core/tutorials/first-web-api?view=aspnetcore-7.0&tabs=visual-studio-code#add-a-model-class

Conteneurisation de l’API :

1 . Création du fichier Dockerfile :

• Ouvrir la palette de commande (CTRL + Shift + P)
• Taper “.NET: Generate Assets for Build and Debug”

Cette commande permet de créer les fichiers launch.json et task.json qui permettent le débogage sur VSCode.

• Ré-ouvrir la palette de commande (CTRL + Shift + P)
• Taper “Docker: Add Docker Files to Workspace”

• Sélectionner “.NET: ASP.NET Core”

• Sélectionner “Linux” pour le système d’exploitation

• Entrez le port de votre choix (ex: 5000)

• Sélectionner “No” pour le fichier docker-compose car nous n’avons pas plusieurs conteneurs à créer

• Les fichiers Dockerfile et .dockerignore ont été généré
• Ouvrer le Dockerfile
• Ajouter la ligne en gras :

FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
WORKDIR /app
EXPOSE 5000

ENV ASPNETCORE_URLS=http://+:5000
ENV ASPNETCORE_ENVIRONMENT=Development //Permet d'afficher l'interface UI de Swagger

# Creates a non-root user with an explicit UID and adds permission to access the /app folder
# For more info, please refer to https://aka.ms/vscode-docker-dotnet-configure-containers
RUN adduser -u 5678 --disabled-password --gecos "" appuser && chown -R appuser /app
USER appuser

FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
WORKDIR /src
COPY ["MyWebApi.csproj", "./"]
RUN dotnet restore "MyWebApi.csproj"
COPY . .
WORKDIR "/src/."
RUN dotnet build "MyWebApi.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "MyWebApi.csproj" -c Release -o /app/publish /p:UseAppHost=false

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "MyWebApi.dll"]

2 . Build l’application

• Dans le terminal VSCode (CTRL + Shift + ù), exécuter la commande suivante :

dotnet build

3 . Création de l’image docker

• Dans le terminal VSCode (CTRL + Shift + ù), exécuter la commande suivante :

docker build -t mywebapi:latest .

Ici -t sert a préciser le tag de l’image que l’on créer et permet de préciser la version de l’image.

• Vérifier que l’image a bien été créer avec la commande grâce à l’interface docker de VSCode :

• ou avec la commande suivante :

docker images

• Avant de construire le container assurez vous que le port 5000 n’est pas utilisé par un autre service. C’est à dire qu’il faut que votre “dotnet run” de test de l’API (Etape 2 . Test de l’application) ne soit pas en cours d’exécution, soit en fermant le terminal ou en faisant CTRL + C dans le terminal.

4 . Création du container

• Dans le terminal VSCode (CTRL + Shift + ù), exécuter la commande suivante :

docker run --rm -d -p 5000:5000/tcp --name mywebapi mywebapi:latest

– –rm : permet de supprimer le container dès qu’il sera stoppé

-d : permet de démarrer le container en mode détaché

-p 5000:5000/tcp : permet de préciser le port de l’hôte que l’on associe au port du container

– –name mywebapi : permet de préciser le nom du container que l’on créer, ici “mywebapi”

• Vérifier que le container a bien été créé avec l’interface docker de VSCode :

• ou avec la commande :

docker ps

• Tester l’API dans un navigateur : http://localhost:5000/swagger/index.html

=> l’interface Swagger doit apparaître comme vu précédemment.

Déboguer le container :

• Dans “Run and Debug” de VSCode (CTRL + SHIFT + D)

• Cliquer sur “Add Configuration” (c’est peut être écrit .NET Core Launch (web)) et selectionner “Docker .NET Core Launch”

• Aller dans ./Controllers/WeatherForecastController.cs et ajouter un point d’arrêt sur la ligne 20

• Cliquer sur la flèche verte pour lancer le débogage

• Dans un navigateur (la page qui s’ouvre automatiquement), entrer l’url suivant : http://localhost:/swagger/index.html

=> l’interface Swagger s’affiche comme précédemment

• Tester l’API:
  • GET /weatherforecast
  • Try it out
  • Execute
  • Observer que la page est en “Loading”

• Dans ./Controllers/WeatherForecastController.cs observer le breakpoint

Déboguer en local :

Le principe est le même que la partie ci-dessus mise à part qu’il ne faut pas sélectionner : “Docker .NET Core Launch” mais “.NET Core Launch (web)” pour lancer le débogage en local.