Que sont les conteneurs dans l’informatique en nuage (cloud computing) ?

Depuis l’apparition de Docker en 2013, la popularité des conteneurs a explosé. Un grand nombre d’entreprises les ont déjà intégrés dans leurs processus de travail, dans la mesure où ils leur permettent de facilement déployer, distribuer, gérer et mettre à l’échelle leurs logiciels.

Dans cet article, nous expliquerons ce que sont les conteneurs dans l’informatique en nuage. Nous présenterons les avantages de l’utilisation des conteneurs, leurs domaines d’application, nous les comparerons aux machines virtuelles et nous nous pencherons sur Docker et Kubernetes. Enfin, nous vous apprendrons comment coder, dockeriser et déployer une application web sur Back4app Containers—  et ce gratuitement !

Qu’est-ce qu’un conteneur ?

Un conteneur est un package exécutable autonome qui regroupe tout ce qui est nécessaire à l’exécution d’une application : code, runtime, bibliothèques, variables d’environnement et fichiers de configuration. La particularité des applications conteneurisées est qu’elles peuvent être exécutées n’importe où, que ce soit dans votre environnement de développement local ou dans les clouds publics, etc. Les conteneurs sont de petite taille, ils sont efficaces et permettent d’isoler efficacement les applications.

Les avantages de l’utilisation des conteneurs

L’utilisation de conteneurs présente plusieurs avantages. En voici quelques-uns.

L’efficacité

Les conteneurs requièrent moins de ressources système que les serveurs traditionnels ou les machines virtuelles, car ils n’incluent pas d’image de système d’exploitation. Cela les rend extrêmement efficaces, de petite taille (généralement mesurée en Mo), ce qui vous permet d’exécuter un grand nombre d’applications sur un seul serveur.

L’isolation de l’application

Les conteneurs isolent l’application et ses dépendances du système hôte. Parallèlement, ils peuvent partager le noyau du système d’exploitation et les ressources du système telles que l’unité centrale, la mémoire, le stockage et le réseau.

La portabilité

Les logiciels conteneurisés peuvent s’exécuter et fonctionner de la même manière sur quasiment toutes les machines sur lesquelles est installé un moteur de conteneurisation (container engine). Il est donc facile de déployer et de déplacer des applications entre différents environnements et de résoudre le problème “ça fonctionne sur mon appareil”.

La séparation des responsabilités

Les conteneurs permettent de répartir les tâches et les responsabilités entre les développeurs et les équipes d’exploitation informatique. Les développeurs sont responsables de la création et de la maintenance du code de l’application et des dépendances, tandis que les équipes d’exploitation informatique se concentrent sur le déploiement et la gestion des conteneurs et de l’infrastructure sous-jacente.

Un développement d’applications plus rapide

La conteneurisation facilite le développement, les essais, la gestion et la distribution des logiciels. Les conteneurs peuvent être facilement intégrés aux systèmes CI/CD, ce qui permet d’accélérer considérablement le processus de développement et de distribution des logiciels.

Une mise à l’échelle simplifiée

Les applications conteneurisées combinées à une plateforme d’orchestration comme Kubernetespeuvent facilement évoluer à la demande. Cela permet à votre entreprise de s’adapter à des charges de travail élevées avec des coûts réduits.

Cas d’utilisation des conteneurs

Il existe de nombreux cas d’utilisation de la technologie des conteneurs, tant pour les développeurs que pour les équipes d’exploitation informatique.

Développement Natif des Conteneurs

Le développement natif des conteneurs (Container-Native Development) est une approche de développement logiciel qui utilise les conteneurs comme un élément de base. Dans le cadre du développement natif de conteneurs, les applications sont présentées sous forme de conteneurs et s’exécutent dans un environnement conteneurisé. Cette approche de développement vous permet de bénéficier de tous les avantages des conteneurs.

Intégration Continue (“Continuous Integration”) et Livraison Continue (“Continuous Delivery”) (CI/CD)

Dans un pipeline CI/CD, les conteneurs sont utilisés pour packager les applications et exécuter des tests automatisés, ce qui permet de tester et de déployer les applications de manière cohérente et reproductible. Les conteneurs peuvent être facilement créés, testés et déployés dans le cadre du pipeline CI/CD, ce qui réduit le risque d’erreurs et améliore l’efficacité globale du processus de développement logiciel.

Microservices

Les conteneurs peuvent être utilisés pour développer des applications qui suivent une architecture microservice. Les conteneurs vous permettent de diviser facilement votre application monolithique en une collection de services finement détaillés et faiblement couplés, qui s’exécutent dans différents conteneurs.

Environnement de développement

Les conteneurs facilitent la mise en place rapide d’environnements de développement par les équipes de développeurs. Ils fournissent des environnements de développement cohérents, quels que soient le système d’exploitation et les bibliothèques hôtes.

Traitement par lot (batch)

Les traitements par lots peuvent être facilement conteneurisés et déployés dans le cloud. Chaque tâche est présentée sous la forme d’une image de conteneur individuelle et exécutée en tant qu’instance de conteneur séparée. Cela permet une utilisation efficace des ressources, car chaque tâche s’exécute dans son propre environnement et n’interfère pas avec les autres tâches.

Conteneurs vs. Machines Virtuelles

Les conteneurs et les machines virtuelles sont deux approches différentes de la virtualisation. Bien qu’elles présentent certaines similitudes, elles sont très différentes.

Les machines virtuelles (VM) constituent une abstraction du matériel physique. Elles nous permettent de transformer un serveur en plusieurs serveurs. Chaque machine virtuelle possède son propre système d’exploitation et est généralement gérée par un hyperviseur. Les machines virtuelles sont adaptées à l’exécution d’applications multiples (sur le même serveur), d’applications monolithiques et d’applications nécessitant un haut degré d’isolation et de sécurité. Elles présentent l’inconvénient d’occuper beaucoup d’espace et d’être assez lentes au démarrage.

Les conteneurs, quant à eux, sont virtualisés au niveau du système d’exploitation. Ils prennent moins de place puisqu’ils partagent le même noyau Linux, ils sont plus performants, ils démarrent plus rapidement, ils sont très évolutifs et ils peuvent gérer plus d’applications. Les conteneurs sont gérés par un Moteur de conteneurisation (Container Engine). Contrairement aux machines virtuelles, les conteneurs sont principalement utilisés pour les microservices et les applications qui doivent être portables, légères et évolutives.

On peut également combiner les conteneurs et les machines virtuelles pour bénéficier de leurs avantages respectifs.

Docker et Kubernetes

Docker et Kubernetes sont deux outils très populaires pour travailler avec des conteneurs. Voyons comment ils fonctionnent et quelles sont leurs différences.

Docker est un projet open-source basé sur Linux qui est utilisé pour automatiser le déploiement et la gestion d’applications dans des conteneurs légers. Les applications conteneurisées peuvent ainsi fonctionner efficacement dans différents environnements. Actuellement, Docker est presque omniprésent, que ce soit sur les machines Linux ou chez les grands fournisseurs de services en cloud, etc.

Les alternatives les plus populaires à Docker sont Podman, LXD et containerd.

Kubernetes (K8s) est un système d’orchestration de conteneurs open-source permettant d’automatiser le déploiement, la mise à l’échelle et la gestion des applications conteneurisées. Depuis sa sortie en 2014, ce système s’est imposé comme la norme de facto pour le déploiement et l’exploitation d’applications conteneurisées dans des environnements cloud. Kubernetes offre de nombreux avantages notamment en termes d’évolutivité, de haute disponibilité, d’automatisation des opérations, d’abstraction de l’infrastructure et de surveillance de santé.

Il existe d’autres plateformes d’orchestration, notamment : AWS ECS, Nomad et Red Hat OpenShift.

Quelle est donc la différence entre Docker et Kubernetes ? En termes simples, Docker nous permet de packager et de distribuer des applications à l’intérieur de conteneurs, tandis que Kubernetes permet à plusieurs conteneurs de travailler en harmonie les uns avec les autres.

Développement d’une application à l’aide d’une architecture à base de conteneurs

Dans cette partie du tutoriel, nous allons créer, dockeriser et déployer une simple API REST sur Back4app Containers.

Qu’est-ce que Back4app Containers ?

Back4app Containers est une plateforme open-source gratuite pour déployer et mettre à l’échelle des applications sur des conteneurs distribués globalement dans une infrastructure cloud.

Cette plateforme vous permet de vous concentrer sur votre logiciel et de le livrer plus rapidement sans avoir à vous soucier de DevOps. Elle est étroitement intégrée à GitHub, elle possède un système CI/CD intégré, et vous permet de mettre en place votre application en quelques minutes !

Pourquoi utiliser Back4app Containers ?

• Bien intégrée à GitHub
• Déploiement sans temps d’arrêt
• Facile à utiliser et offre un niveau gratuit
• Excellent service client

Présentation du projet

Nous allons créer une API REST toute simple qui servira de liste de visionnage de films. Cette application web permettra de réaliser des opérations CRUD basiques comme l’ajout ou la suppression d’un film, et ainsi de suite. Pour créer l’API, nous utiliserons le framework Flask. Pour finir, nous allons Dockeriser le projet et démontrer à quel point il est facile de le déployer sur Back4app Containers.

Prérequis

• Expérience avec le framework Flask
• Compréhension de base de Docker et des conteneurs
• Capacité à utiliser Git et GitHub

Code App

Les étapes suivantes nécessitent l’installation de Python. Si vous n’avez pas encore installé Python, téléchargez-le.

Initialisation du projet

Tout d’abord, créez un répertoire dédié à votre application et accédez-y :  

$ mkdir flask-watchlist
$ cd flask-watchlist

Créez ensuite un nouvel environnement virtuel et activez-le :

$ python3 -m venv venv && source venv/bin/activate

Étant donné que nous allons utiliser Flask comme framework, nous devons l’installer :

$ (venv) pip install Flask==2.2.2

Créons app.py avec le contenu suivant :

# app.py

from flask import Flask

app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False


@app.route('/')
def index_view():
    return {
        'detail': 'Hello world!'
    }

Ce code initialise Flask et crée un point d’extrémité simple qui renvoie un message.

Exécutez le serveur avec :

$ flask run

Allez sur http://localhost:5000/ et vous devriez voir un message disant Hello world!.

Base de données

Pour la base de données, nous utiliserons SQLite. SQLite est un système de gestion de base de données relationnelle intégré, sans serveur. Pour simplifier le travail avec la base de données, nous allons installer Flask-SQLAlchemy — une extension pour Flask qui intègre une prise en charge de SQLAlchemy dans votre application.

Installez-la en exécutant :

$ (venv) pip install Flask-SQLAlchemy==3.0.3

Ensuite, rendez-vous au début de app.py et modifiez-le comme suit pour initialiser la base de données :

# app.py

db = SQLAlchemy()
app = Flask(__name__)
app.config['JSON_SORT_KEYS'] = False
app.config['SECRET_KEY'] = '5b3cd5b80eb8b217c20fb37074ff4a33'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///default.db"
db.init_app(app)

N’oubliez pas l’importation :

from flask_sqlalchemy import SQLAlchemy

Ensuite, définissons nos modèles de base de données.

Puisque nous créons une simple application de liste de visionnage de films, nous n’aurons besoin que d’un seul modèle. Définissons le modèle Movie comme suit :

# app.py

class Movie(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(128), nullable=False)
    release_date = db.Column(db.Date(), nullable=False)

    is_watched = db.Column(db.Boolean, default=False)
    watched_at = db.Column(db.DateTime, default=None, nullable=True)

    def as_dict(self):
        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

    def __repr__(self):
        return '<Movie %r>' % self.title

Pour initialiser et alimenter notre base de données, nous allons créer un simple script Python. Allez à la racine de votre projet et créez un nouveau fichier nommé init_db.py avec le contenu suivant :

# init_db.py

from datetime import date

from app import db, app
from app import Movie

with app.app_context():
    db.create_all()

    if Movie.query.count() == 0:
        movies = [
            Movie(title='Fight Club', release_date=date(1999, 9, 15)),
            Movie(title='The Matrix', release_date=date(1999, 3, 31)),
            Movie(title='Donnie Darko', release_date=date(2001, 1, 19)),
            Movie(title='Inception', release_date=date(2010, 7, 16)),
        ]

        for movie in movies:
            db.session.add(movie)

        db.session.commit()

Il ne reste plus qu’à exécuter le script :

$ (venv) python init_db.py

Cette opération crée la base de données, les tables de la base de données et les renseigne. Le fichier de la base de données sera placé dans le dossier instance.

Points d’extrémité de l’API

Notre application web aura les points d’extrémité (“endpoints”) suivants :

1. / renvoie les informations de base de l’API
2. /api/ renvoie la liste des films
3. /api/create/ ajoute un nouveau film à la liste de visionnage
4. /api/<movie_id>/ renvoie les détails d’un film spécifique
5. /api/watch/<movie_id>/ marque le film comme étant vu

Définissez les points de terminaison en bas de app.py:

# app.py

@app.route('/')
def index_view():
    return {
        'name': 'flask-watchlist',
        'description': 'a simple app for tracking the movies you want to watch',
        'version': 1.1,
    }


@app.route('/api/')
def list_view():
    json = [movie.as_dict() for movie in Movie.query.all()]
    return jsonify(json)


@app.route('/api/<int:movie_id>/', methods=['GET', 'DELETE'])
def detail_view(movie_id):
    movie = db.get_or_404(Movie, movie_id)

    if request.method == 'DELETE':
        db.session.delete(movie)
        db.session.commit()

        return {
            'detail': 'Movie has been successfully deleted.'
        }
    else:
        return movie.as_dict()


@app.route('/api/create/', methods=['POST'])
def create_view():
    title = request.form.get('title')
    release_date = request.form.get('release_date', type=float)

    if title is None or release_date is None:
        return {
            'detail': 'Please provide the title and release_date.'
        }, 400

    movie = Movie(title=title, release_date=datetime.fromtimestamp(release_date))
    db.session.add(movie)
    db.session.commit()

    return movie.as_dict()


@app.route('/api/watch/<int:movie_id>/')
def watch_view(movie_id):
    movie = db.get_or_404(Movie, movie_id)

    if movie.is_watched:
        return {
            'detail': 'Movie has already been watched.'
        }, 400

    movie.is_watched = True
    movie.watched_at = datetime.now()
    db.session.commit()

    return movie.as_dict()

N’oubliez pas les importations :

from datetime import datetime
from flask import request, jsonify

Parfait, notre application est maintenant plus ou moins complète. Lançons le serveur de développement :

$ (venv) flask run

Vérifiez que vous pouvez récupérer la liste des films :

$ (venv) curl http://localhost:5000/api/ | jq '.'

[
  {
    "id": 1,
    "title": "Fight Club",
    "release_date": "Wed, 15 Sep 1999 00:00:00 GMT",
    "is_watched": false,
    "watched_at": null
  },
  {
    "id": 2,
    "title": "The Matrix",
    "release_date": "Wed, 31 Mar 1999 00:00:00 GMT",
    "is_watched": false,
    "watched_at": null
  },
  ...
]

Gunicorn

Le serveur de développement Flask n’est pas adapté à la production, alors remplaçons-le par Gunicorn. Gunicorn ou “Green Unicorn” est un serveur HTTP WSGI de Python pour Unix, prêt pour la production.

Installez-le en exécutant :

$ (venv) pip install gunicorn==20.1.0

Une fois le package installé, vous pouvez démarrer votre serveur WSGI comme suit :

$ (venv) gunicorn -w 2 -b 0.0.0.0:5000 app:app

[INFO] Starting gunicorn 20.1.0
[INFO] Listening at: http://0.0.0.0:5000 (1)
[INFO] Using worker: sync
[INFO] Booting worker with pid: 7
[INFO] Booting worker with pid: 8

Gardez à l’esprit que cette commande ne fonctionne que sur les systèmes d’exploitation basés sur UNIX.

Ceci va lancer deux travailleurs Gunicorn et rendre votre application accessible à Internet. Pour accéder à l’application, ouvrez votre navigateur web préféré et allez sur http://localhost:5000.

requirements.txt

Avant de Dockeriser notre application, il nous faut créer un fichier requirements.txt. Celui-ci est utilisé pour spécifier les dépendances du projet.

La façon la plus simple de le générer est d’exécuter la commande :

$ (venv) pip freeze > requirements.txt

Dockeriser l’application

Les étapes suivantes nécessitent l’installation de Docker. La façon la plus simple consiste à télécharger Docker Desktop.

Pour vérifier que vous avez installé Docker, exécutez :

$ docker --version

Docker version 20.10.22, build 3a2c30b

Dockerfile

Pour dockeriser notre application, nous utiliserons un Dockerfile. Un Dockerfile est un fichier texte qui nous permet de définir l’image de base, l’environnement, les variables environnementales, les commandes, les paramètres réseau, les volumes, etc.

Créons un Dockerfile à la racine de notre projet avec le contenu suivant :

# syntax=docker/dockerfile:1.4
FROM --platform=$BUILDPLATFORM python:3.10-alpine

# set the working directory
WORKDIR /app

# set environmental variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# install the requirements
COPY requirements.txt /app
RUN --mount=type=cache,target=/root/.cache/pip \
    pip3 install -r requirements.txt

# copy the code to the container
COPY . .

# initialize the database (create DB, tables, populate)
RUN python init_db.py

# expose
EXPOSE 5000/tcp

# entrypoint command
CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:5000", "app:app"]

1. Nous avons utilisé python:3.10-alpine comme image de base.
2. En mettant PYTHONDONTWRITEBYTECODE à 1 Python n’écrira plus les fichiers .pyc sur le disque.
3. En mettant PYTHONUNBUFFERED à 1 on s’assure que les flux de sortie de Python sont envoyés directement au terminal.

Pour plus d’informations sur l’écriture de Dockerfiles, consultez la référence Dockerfile.

.dockerignore

Avant de créer une image, Docker recherche un fichier .dockerignore. Un fichier .dockerignore nous permet de définir les fichiers que nous ne voulons pas inclure dans l’image. Cela peut réduire considérablement la taille de l’image. Son fonctionnement est similaire à celui d’un fichier .gitignore.

Créez un fichier .dockerignore à la racine du projet avec le contenu suivant :

# .dockerignore

.git/
instance/
__pycache__/
.idea/

Assurez-vous d’ajouter tout répertoire ou fichier supplémentaire que vous souhaitez exclure.

Construire et exécuter l’image

Continuons, et créons et marquons notre image Docker.

$ docker build -t flask-watchlist:1.0 .

[+] Building 11.1s (15/15) FINISHED
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s 
 => => transferring dockerfile: 32B                                                                                                                                                                                                                                                                                0.0s 
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s 
 => => transferring context: 34B                                                                                                                                                                                                                                                                                   0.0s 
 => resolve image config for docker.io/docker/dockerfile:1.4                                                                                                                                                                                                                                                       0.5s 
 => CACHED docker-image://docker.io/docker/dockerfile:1.4@sha256:9ba7531a0dbc                                                                                                                                                                                  0.0s 
 => [internal] load build definition from Dockerfile                                                                                                                                                                                                                                                               0.0s 
 => [internal] load .dockerignore                                                                                                                                                                                                                                                                                  0.0s 
 => [internal] load metadata for docker.io/library/python:3.10-alpine                                                                                                                                                                                                                                              0.5s 
 => [stage-0 1/6] FROM docker.io/library/python:3.10-alpine@sha256:da5ab5e911253dfb                                                                                                                                                                                0.0s 
 => [internal] load build context                                                                                                                                                                                                                                                                                  0.3s 
 => => transferring context: 182.45kB                                                                                                                                                                                                                                                                              0.2s 
 => CACHED [stage-0 2/6] WORKDIR /app                                                                                                                                                                                                                                                                              0.0s 
 => [stage-0 3/6] COPY requirements.txt /app                                                                                                                                                                                                                                                                       0.0s 
 => [stage-0 4/6] RUN --mount=type=cache,target=/root/.cache/pip     
                      pip3 install -r requirements.txt                                                                                                                                                                                                              7.2s 
 => [stage-0 5/6] COPY . .                                                                                                                                                                                                                                                                                         0.3s 
 => [stage-0 6/6] RUN python init_db.py                                                                                                                                                                                                                                                                            1.5s 
 => exporting to image                                                                                                                                                                                                                                                                                             0.3s 
 => => exporting layers                                                                                                                                                                                                                                                                                            0.3s 
 => => writing image sha256:2671ccb7546a0594807c721a0600a                                                                                                                                                                                                                       0.0s 
 => => naming to docker.io/library/flask-watchlist:1.0 

Si on liste les images, on devrait trouver notre nouvelle image :

$ docker images

REPOSITORY        TAG       IMAGE ID       CREATED       SIZE
flask-watchlist   1.0       7bce66230eb1   8 hours ago   110MB

Enfin, on va utiliser l’image pour créer un nouveau conteneur Docker :

$ docker run -it -p 5000:5000 flask-watchlist:1.0

[2023-02-02 20:08:57 +0000] [1] [INFO] Starting gunicorn 20.1.0
[2023-02-02 20:08:57 +0000] [1] [INFO] Listening at: http://0.0.0.0:5000 (1)
[2023-02-02 20:08:57 +0000] [1] [INFO] Using worker: sync
[2023-02-02 20:08:57 +0000] [7] [INFO] Booting worker with pid: 7
[2023-02-02 20:08:57 +0000] [8] [INFO] Booting worker with pid: 8

Vous pouvez utiliser -d pour lancer le conteneur Docker en mode détaché. Cela signifie que le conteneur s’exécute en arrière-plan de votre terminal et ne reçoit pas d’entrée et n’affiche pas de sortie.

Bien joué, votre application est désormais exécutée dans un conteneur ! Allez sur http://localhost:5000 et vous devriez obtenir la réponse suivante :

{
    "name": "flask-watchlist",
    "description": "a simple app for tracking the movies you want to watch",
    "version": 1
}

GitHub

Pour déployer l’application sur Back4app Containers, vous devez télécharger votre code source sur un dépôt GitHub. Continuez et créez un nouveau dépôt sur GitHub, ajoutez le remote, ajoutez .gitignore, et validez votre code. Une fois que votre code est sur GitHub, passez à l’étape suivante.

Déployer l’application sur Back4app Containers

Pour effectuer les étapes suivantes, vous devez avoir un compte Back4app. Si vous l’avez déjà, connectez-vous, sinon inscrivez-vous pour obtenir un compte gratuit.

Pour travailler avec Back4app, nous devons d’abord créer une application. Lorsque vous vous connectez à votre tableau de bord, vous verrez la liste de vos applications. Cliquez sur “Build a new app” pour créer une nouvelle application.

Ensuite, sélectionnez “Containers as a Service” (conteneurs en tant que service).

Si vous ne l’avez pas encore fait, connectez votre GitHub à Back4app et importez les dépôts que vous souhaitez déployer. Une fois que votre GitHub est connecté, vos dépôts seront affichés dans le tableau.

Choisissez le dépôt que vous souhaitez déployer en cliquant sur “Select”.

Ensuite, Back4app va vous demander de configurer l’environnement. Choisissez un nom d’application, je vais choisir flask-watchlist. Vous pouvez laisser tout le reste par défaut.

Enfin, cliquez sur “Create App” pour créer automatiquement l’application et la déployer.

Vous serez alors redirigé vers les détails de votre application où vous pourrez voir les logs de déploiement.

Attendez quelques minutes pour que l’application se déploie et voilà ! Votre application est maintenant en ligne sur Back4app Containers. Pour voir votre application en action, cliquez sur l’URL verte affichée à gauche.

Conclusion

Tout au long de cet article, nous avons expliqué en quoi consistent les conteneurs, quels sont leurs avantages et comment vous pouvez les intégrer dans votre flux de travail. À ce stade, vous devriez être en mesure de construire votre propre API REST simple, de la dockeriser et de la déployer dans Back4app Containers.

Téléchargez le code source final depuis le dépôt GitHub.

Future steps

1. Vous ne devriez pas conserver la base de données dans votre image. Pour l’instant, chaque redéploiement va réinitialiser la base de données. Envisagez de passer à une instance PostgreSQL or MySQL gérée.
2. Apprenez à créer des builds multi-stagespour optimiser vos Dockerfiles.
3. Reportez-vous à l’article Deploying Docker Containers « Déployer des conteneurs Docker » pour un tutoriel détaillé

FAQ