Déploiement d’applications ASP.NET Core avec Docker – Partie 2

De par sa flexibilité et sa simplicité, Docker facilite la gestion des applications et de leurs dépendances. Dans cette deuxième partie sur Docker avec ASP.NET Core, nous verrons comment ajouter une base de données SQL Server à l’application et comment l’exécuter dans un conteneur Docker à l’aide de Docker Compose.

Dans le première partienous avons vu une introduction à Docker, comprenant son fonctionnement et ses avantages par rapport aux machines virtuelles. De plus, nous avons créé notre premier Dockerfile et exécuté les commandes pour déployer une application ASP.NET Core MVC exécutée dans un conteneur Docker.

Dans cet exemple, nous avons utilisé les ressources de stockage en mémoire .NET comme base de données, mais dans des scénarios réels, il est courant d’utiliser des bases de données SQL telles que SQL Server et MySQL. Et c’est ce que nous aborderons dans cet article.

À l’aide de l’application du dernier article, nous allons créer une connexion à une base de données SQL Server et créer un conteneur pour celle-ci. De plus, nous verrons comment configurer Docker pour exécuter les commandes Entity Framework Core lors du déploiement d’une nouvelle image Docker de l’application.

Configuration de l’application de base

Dans cet article, nous profiterons de l’application créée dans la première partie, en modifiant simplement ce qui est nécessaire. Ainsi, vous pouvez utiliser la commande Git suivante pour télécharger l’application de base via HTTPS. Si vous préférez, vous pouvez accéder au référentiel distant à ce lien : https://github.com/zangassis/reminder-list.

git clone https://github.com/zangassis/reminder-list.git

Ensuite, ajoutons les dépendances Entity Framework Core et SQL Server à l’application. Ouvrez le projet avec votre éditeur de code et cliquez sur le fichier avec le .csproj extension. Ajoutez-y le code suivant :

<PackageReference Include="Microsoft.EntityFrameworkCore .Design" Version="9.0.0">
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
      <PrivateAssets>all</PrivateAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.EntityFrameworkCore .SqlServer" Version="9.0.0" />

Créons maintenant une classe pour exécuter les commandes de migration et créons la base de données et les tables lorsque l’application est exécutée dans le conteneur Docker.

Dans le dossier Data, ajoutez la classe suivante :

• Service de gestion de base de données

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Storage;

namespace ReminderList.Data
{
    public static class DatabaseManagementService
    {
        public static void MigrationInitialisation(IApplicationBuilder app)
        {
            using (var serviceScope = app.ApplicationServices.CreateScope())
            {
                var context = serviceScope.ServiceProvider.GetRequiredService<TodoContext>();

                if (!context.Database.GetService<IRelationalDatabaseCreator>().Exists())
                {
                    context.Database.Migrate();
                }
            }
        }
    }
}

Ici, le CreateScope() La méthode crée une étendue pour accéder aux services dépendants enregistrés dans le IServiceCollectiontel que ApplicationDbContext. Ensuite, le serviceScope.ServiceProvider.GetRequiredService<ApplicationDbContext>() récupère une instance de ApplicationDbContextqui est la classe responsable de l’interaction avec la base de données. Enfin, si la base de données n’existe pas, le Migrate() La méthode applique toutes les migrations en attente, mettant à jour le schéma de base de données en fonction des définitions des migrations générées dans le projet.

Désormais, nous n’avons plus besoin de la configuration de la mémoire de la base de données, mais plutôt de la configuration de SQL Server. Alors, ouvrez le fichier Program.cs et supprimez les paramètres suivants :

builder.Services.AddDbContext<TodoContext>(options =>
	options.UseInMemoryDatabase("TodoList"));

Et puis ajoutez ce qui suit :

var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");

builder.Services.AddDbContext<TodoContext>(options =>
    options.UseSqlServer(connectionString));

Et juste après l’extrait de code app.UseAuthorization();ajoutez l’appel au MigrationInitialisation() méthode qui exécutera les commandes de migration lorsque l’application sera construite dans le conteneur Docker :

DatabaseManagementService.MigrationInitialisation(app);

Ajoutons maintenant la chaîne de connexion dans le appsettings.json déposer. Ouvrez le fichier appsettings.json et ajoutez ce qui suit :

"ConnectionStrings": {
    "DefaultConnection": "Server=mssql-server,1433;Initial Catalog=TodoListDb;User ID=SA;Password=8/geTo'7l0f4;TrustServerCertificate=true"
  },

Ici, nous définissons les paramètres de la base de données SQL Server, tels que le nom de la base de données, l’ID utilisateur et le mot de passe, entre autres. Ces paramètres seront les mêmes que ceux utilisés lors de la création du conteneur Docker SQL Server. Ainsi, pour que l’application puisse se connecter à la base de données dans le conteneur, ces informations d’identification doivent être configurées correctement.

Création du fichier Docker Compose

Docker Compose est un outil qui vous permet de définir et d’exécuter des applications dans plusieurs conteneurs Docker.

Il utilise un fichier de configuration, communément appelé docker-compose.ymloù sont configurés les services qui composent l’application, tels que les API, les bases de données, les services de journalisation, etc.

Compose est utile dans les scénarios où il est nécessaire de gérer plusieurs conteneurs. Par exemple, dans une application backend dans ASP.NET Core, le premier conteneur serait destiné à l’exécutable de l’application et le second serait destiné à la base de données (par exemple SQL Server ou PostgreSQL). Et un troisième conteneur pour des outils supplémentaires (par exemple Redis, Nginx, etc.).

Au lieu de créer un Dockerfile pour chaque service, nous pouvons créer un Docker Compose pour tous les services.

Dans le scénario de l’article, nous aurons besoin d’un conteneur pour l’application Web et d’un deuxième conteneur pour la base de données SQL Server. Ainsi, dans le dossier racine du projet, créez un nouveau fichier appelé docker-compose.yml et à l’intérieur, ajoutez le code ci-dessous :

version: '3'
services:
  mssql-server:
    image: mcr.microsoft.com/mssql/server:2022-latest
    environment:
      ACCEPT_EULA: "Y"
      SA_PASSWORD: "8/geTo'7l0f4"
      MSSQL_PID: Express
    ports:
      - "1433:1433"
    volumes:
        - ./sqlserver-data/volumes/sqlserver:/var/opt/mssql/data
  todo-app:
    build: .
    environment:
      ASPNETCORE_ENVIRONMENT: "Development"
    ports: 
      - "8090:80"

Maintenant, analysons chaque partie de ce code.

• version : ‘3’: Définit la version de Docker Compose à utiliser. Dans ce cas, la version 3 est utilisée pour les projets modernes.

• services: Contient la définition des services qui seront exécutés.

• serveur mssql: configure un conteneur avec la base de données Microsoft SQL Server.

• image: utilise la dernière image officielle SQL Server 2022 disponible dans Microsoft Container Registry.

• environnement: Définit les variables d’environnement pour configurer le serveur SQL.

• ACCEPT_EULA : « O »: Accepte les termes du contrat de licence SQL Server.

• SA_PASSWORD : « 8/geTo’7l0f4 » Définit le mot de passe de l’administrateur système (SA). Respecter les règles de sécurité de SQL Server (minimum de 8 caractères, avec lettres majuscules, lettres minuscules, chiffres et caractères spéciaux).

• MSSQL_PID : « Exprimer »: configure SQL Server pour qu’il s’exécute dans l’édition gratuite Express.

• ports: Mappe le port 1433 du conteneur au port 1433 de l’hôte.

• volumes : ./sqlserver-data/volumes/sqlserver:/var/opt/mssql/data: monte un volume persistant sur l’hôte pour stocker les données SQL Server, en stockant les données dans le dossier local et en les mappant au /var/opt/mssql/data répertoire à l’intérieur du conteneur.

• tout-application: configure l’application ASP.NET Core.

• construire: Indique que le conteneur sera construit à partir du répertoire courant en utilisant le Dockerfile dans ce répertoire.

• environnement-: définit les variables d’environnement pour l’application.

• ASPNETCORE_ENVIRONMENT : « Développement »: Définit l’environnement d’application sur Développement.

• ports: Mappe le port 80 du conteneur sur le port 8090 de l’hôte, permettant l’accès à l’application via http://localhost:8090.

Exécuter des commandes de composition

Avant d’exécuter la commande pour conserver le fichier docker-compose, il est nécessaire de générer les fichiers de migration EF Core, de sorte que lorsque le conteneur est créé, la base de données et les tables soient également créées.

Alors, ouvrez un terminal à la racine de l’application et exécutez la commande suivante :

dotnet ef migrations add InitialCreate

Nous pouvons maintenant exécuter la commande docker qui créera les conteneurs. Dans le terminal, exécutez la commande suivante :

docker compose up --build

Expliquons chaque commande :

Reconstruire les images de conteneurs: Le --build Le paramètre force Docker Compose à reconstruire les images du conteneur.

Services de téléchargement: La commande docker-compose up démarre les services définis dans le fichier docker-compose.yml. Il crée et initialise les conteneurs de services, en les connectant selon la configuration réseau définie.

Si tout se passe bien, vous pouvez vérifier les images et les conteneurs créés sur le bureau Docker.

Notez qu’il existe un conteneur pour la base de données SQL Server et un autre conteneur pour l’application, donc si nous avions plus d’applications, elles pourraient toutes accéder à la même base de données qui s’exécute dans le conteneur Docker.

Tester l’application

Vous pouvez maintenant accéder à l’application dans le navigateur pour vérifier si tout fonctionne correctement. Alors, dans le navigateur, accédez à l’adresse : https://localhost:8090/Todo et essayez de créer une nouvelle tâche :

Vous pouvez accéder au code source avec les modifications postées dans ce référentiel GitHub : Code source.

Désormais, l’application Web que nous avons créée n’accède plus à la base de données en mémoire. Au lieu de cela, il accède au serveur SQL sur lequel une instance est exécutée dans le conteneur. L’image ci-dessous montre un flux de l’exemple créé dans la publication où docker compose crée une image et un conteneur pour SQL Server, en plus d’utiliser le Dockerfile pour créer l’image et le conteneur de l’application ASP.NET Core.

Conclusion

L’utilisation de Docker pour gérer les applications permet l’agilité et l’efficacité du développement et du déploiement du système. Avec quelques configurations et commandes, les développeurs peuvent déployer rapidement des applications dans des environnements isolés, quel que soit le système d’exploitation ou la configuration de la machine. De plus, Docker facilite la mise à l’échelle et la gestion des dépendances, permettant aux équipes de se concentrer davantage sur le développement de fonctionnalités et moins sur la configuration de l’environnement et les problèmes potentiels au cours de ce processus.

Dans cet article, nous avons vu comment améliorer un projet qui utilisait déjà Docker. Dans cet exemple, nous avons créé Docker Compose, qui permet la configuration de plusieurs services, sans avoir besoin d’un fichier Docker par service. Ainsi, nous avons intégré l’application à la base de données SQL Server qui s’exécutait également dans un conteneur Docker. Nous avons également vérifié les détails sur la façon de configurer EF Core pour exécuter les commandes de migration au démarrage du conteneur.

Vous pouvez utiliser Docker pour accélérer le développement, les tests et le déploiement d’applications Web.