Docker sous Linux : Comment automatiser les tests et la surveillance des conteneurs ?

Docker sous Linux : Comment effectuer des tests et un suivi automatisés des conteneurs ?

Avec le développement rapide de la technologie des conteneurs, Docker est devenue l'une des plateformes de conteneurisation les plus populaires. Dans le processus d'utilisation de Docker pour le déploiement et la gestion d'applications, les tests et la surveillance automatisés des conteneurs sont particulièrement importants. Cet article expliquera comment utiliser Docker sous Linux pour les tests et la surveillance automatisés des conteneurs, et fournira des exemples de code correspondants.

1. Test automatisé de Docker

1. Créer un Dockerfile
   Tout d'abord, vous devez créer un Dockerfile pour l'application à tester. Un Dockerfile est un fichier texte qui contient une série d'instructions permettant de créer une image Docker. Voici un exemple simple de Dockerfile :

FROM python:3.8-alpine

WORKDIR /app

COPY requirements.txt ./ 
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

CMD [ "python", "./app.py" ]

Le Dockerfile ci-dessus a été créé pour une application basée sur Python en créant d'abord une nouvelle image basée sur l'image python:3.8-alpine. Définissez ensuite le répertoire de travail sur /app, copiez le fichier de dépendances requirements.txt requis par l'application dans le conteneur et installez les dépendances. Copiez ensuite tous les fichiers du répertoire courant dans le conteneur et utilisez la directive CMD pour spécifier la commande à exécuter au démarrage du conteneur. python:3.8-alpine镜像构建一个新的镜像。然后设置工作目录为/app，将应用程序所需的依赖文件requirements.txt复制到容器中，并安装依赖。接着将当前目录中的所有文件都复制到容器中，并通过CMD指令指定容器启动时执行的命令。

2. 构建和运行容器
   完成Dockerfile的编写后，可以使用docker build命令构建Docker镜像，如下所示：

$ docker build -t myapp:latest .

上述命令将基于当前目录中的Dockerfile构建名为myapp的最新版本镜像。

接下来，使用docker run命令运行容器，并指定相应的端口映射等配置，如下所示：

$ docker run -d -p 8080:8080 --name myapp-container myapp:latest

上述命令将运行名为myapp-container的容器，并将容器内的8080端口映射到主机的8080端口。

3. 编写自动化测试脚本
   为了进行自动化测试，需要编写相应的测试脚本。以Python为例，可以使用unittest模块编写测试用例。以下是一个简单的示例：

import unittest
import requests

class TestApp(unittest.TestCase):
    def setUp(self):
        self.url = 'http://localhost:8080/'

    def tearDown(self):
        pass

    def test_hello(self):
        response = requests.get(self.url + 'hello')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.text, 'Hello, world!')

if __name__ == '__main__':
    unittest.main()

上述示例中，setUp方法用于初始化测试环境，tearDown方法用于清理测试环境。test_hello方法是一个具体的测试用例，使用requests库发送HTTP请求，并进行断言判断返回结果是否符合预期。

4. 运行自动化测试
   完成测试脚本的编写后，可以通过在主机上运行测试脚本来对容器进行自动化测试。假设测试脚本保存为test_app.py，可以使用以下命令运行测试脚本：

$ python test_app.py

二、Docker的监控

1. 使用Prometheus监控
   Prometheus是一款开源的监控系统，它在Docker生态系统中被广泛使用。Prometheus通过采集和存储时间序列数据，并提供灵活的查询和可视化功能，为容器的监控提供了强大的支持。

首先，需要在容器中安装和配置Prometheus。这可以通过在Dockerfile中添加相应的指令来实现，具体步骤如下：

• 下载并安装Prometheus

FROM prom/prometheus:v2.26.0

COPY prometheus.yml /etc/prometheus/

• 创建Prometheus配置文件prometheus.yml

global:
  scrape_interval: 5s

scrape_configs:
  - job_name: 'myapp'
    static_configs:
      - targets: ['myapp-container:8080']

上述配置文件中，scrape_interval指定了数据采集的间隔时间，scrape_configs定义了要监控的目标。

2. 启动Prometheus容器
   完成Dockerfile和配置文件的编写后，可以使用docker run命令启动Prometheus容器，如下所示：

$ docker run -d -p 9090:9090 -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml --name prometheus prom/prometheus:v2.26.0

上述命令将运行名为prometheus的容器，并将容器内的9090端口映射到主机的9090端口，同时将主机上的prometheus.yml文件挂载到容器中。

3. 访问Prometheus Web界面
   完成Prometheus容器的启动后，可以通过浏览器访问http://localhost:9090
Créez et exécutez le conteneur

Après avoir fini d'écrire le fichier Docker, vous pouvez utiliser la commande docker build pour créer l'image Docker, comme indiqué ci-dessous :

rrreee

La commande ci-dessus sera basée sur l'image actuelle du Dockerfile dans le répertoire qui crée la dernière version nommée myapp.

Ensuite, utilisez la commande docker run pour exécuter le conteneur et spécifiez le mappage de port correspondant et d'autres configurations, comme indiqué ci-dessous :

rrreee

La commande ci-dessus exécutera le nom myapp-container Conteneur et mappez le port 8080 du conteneur au port 8080 de l'hôte.
Écrire des scripts de test automatisés
• Afin d'effectuer des tests automatisés, vous devez écrire les scripts de test correspondants. En prenant Python comme exemple, vous pouvez utiliser le module unittest pour écrire des cas de test. Voici un exemple simple :

rrreee🎜Dans l'exemple ci-dessus, la méthode setUp est utilisée pour initialiser l'environnement de test et la méthode tearDown est utilisée pour nettoyer l’environnement de test. La méthode test_hello est un scénario de test spécifique qui utilise la bibliothèque requests pour envoyer des requêtes HTTP et effectuer des assertions afin de déterminer si les résultats renvoyés répondent aux attentes. 🎜

🎜Exécuter des tests automatisés🎜Après avoir terminé l'écriture du script de test, vous pouvez effectuer des tests automatisés sur le conteneur en exécutant le script de test sur l'hôte. En supposant que le script de test est enregistré sous test_app.py, vous pouvez utiliser la commande suivante pour exécuter le script de test : 🎜🎜rrreee🎜2 Surveillance Docker🎜🎜🎜Utiliser la surveillance Prometheus🎜Prometheus est un open source. système de surveillance des sources largement utilisé dans l’écosystème Docker. Prometheus fournit un support puissant pour la surveillance des conteneurs en collectant et en stockant des données de séries chronologiques et en fournissant des fonctions flexibles de requête et de visualisation. 🎜🎜🎜Tout d'abord, Prometheus doit être installé et configuré dans le conteneur. Ceci peut être réalisé en ajoutant les instructions correspondantes dans le Dockerfile. Les étapes spécifiques sont les suivantes : 🎜🎜🎜Téléchargez et installez Prometheus🎜🎜rrreee🎜🎜Créez le fichier de configuration Prometheus prometheus.yml🎜🎜rrreee. 🎜Le fichier de configuration ci-dessus, scrape_interval spécifie l'intervalle de collecte des données et scrape_configs définit les cibles à surveiller. 🎜
🎜Démarrez le conteneur Prometheus🎜Après avoir terminé l'écriture du Dockerfile et des fichiers de configuration, vous pouvez utiliser la commande docker run pour démarrer le conteneur Prometheus, comme indiqué ci-dessous : 🎜🎜rrreee🎜La commande ci-dessus exécutera le conteneur nommé prometheus, mappera le port 9090 du conteneur au port 9090 sur l'hôte et montera le fichier prometheus.yml sur le hôte dans le conteneur. 🎜
🎜Accédez à l'interface Web Prometheus🎜Après avoir terminé le démarrage du conteneur Prometheus, vous pouvez ouvrir l'interface Web Prometheus en accédant à http://localhost:9090 via le navigateur. Dans cette interface, les données peuvent être interrogées et visualisées via le langage de requête PromQL. 🎜🎜🎜Résumé🎜🎜Cet article présente comment utiliser Docker sous Linux pour les tests et la surveillance automatisés des conteneurs. Lors de l'exécution de tests automatisés, vous devez créer un Dockerfile, créer et exécuter le conteneur, puis écrire le script de test correspondant pour les tests. Lors de la surveillance des conteneurs, vous pouvez utiliser Prometheus pour collecter et stocker des données de séries chronologiques, et utiliser PromQL pour les requêtes et la visualisation. Grâce aux méthodes ci-dessus, les conteneurs Docker peuvent être mieux gérés et surveillés pour garantir la stabilité et la fiabilité des applications. 🎜🎜Références : 🎜🎜🎜Documentation officielle de Docker : https://docs.docker.com/🎜🎜Documentation officielle de Prometheus : https://prometheus.io/docs/🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!