Comment utiliser Docker pour une intégration continue et un déploiement continu

Comment utiliser Docker pour l'intégration continue et le déploiement continu

Avec le développement rapide du développement logiciel, l'intégration continue et le déploiement continu sont devenus un élément indispensable du processus de développement logiciel moderne. En tant que plateforme de conteneurisation, Docker peut grandement simplifier le processus d'intégration continue et de déploiement continu. Cet article explique comment utiliser Docker pour l'intégration et le déploiement continus, et fournit des exemples de code spécifiques.

1. Intégration continue

L'intégration continue fait référence à la fusion fréquente des modifications de code des développeurs dans un référentiel partagé, ainsi qu'à leur création et à leurs tests fréquents. L'utilisation de Docker pour l'intégration continue peut simplifier la configuration de l'environnement et le processus de création et améliorer l'efficacité du développement.

1. Créer un Dockerfile

Dockerfile est un fichier de script utilisé pour créer une image Docker. Créez un fichier nommé Dockerfile dans le répertoire racine du projet et ajoutez l'exemple de code suivant :

# 使用官方的 Node.js 镜像作为基础镜像
FROM node:alpine

# 设置工作目录
WORKDIR /app

# 复制 package.json 和 package-lock.json 到工作目录
COPY package*.json ./

# 安装项目依赖
RUN npm install

# 将项目文件复制到工作目录
COPY . .

# 暴露端口
EXPOSE 3000

# 运行应用
CMD ["npm", "start"]

Ce Dockerfile définit une image basée sur Node.js et installe les dépendances du projet dans l'image et les fichiers de l'application et copie le code dans le répertoire de travail. . Enfin, exposez le port et exécutez l'application.

2. Créer l'image Docker

Dans le répertoire racine du projet, utilisez la commande suivante pour créer l'image Docker :

docker build -t my-app .

Cette commande construira une image nommée my-app en fonction de la définition du fichier Dockerfile.

3. Tests conteneurisés

Créez un fichier appelé docker-compose.test.yml dans le répertoire racine du projet et ajoutez l'exemple de code suivant :

version: '3'
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    depends_on:
      - db
    command: npm run test
  db:
    image: mongo

Ce fichier docker-compose.test.yml définit deux services, l'un est le app service, qui est notre service d'application, et l'autre est le service db, qui est notre service de base de données. Ce fichier demande à Docker d'exécuter deux services et d'exécuter des commandes de test dans le service d'application.

Dans le répertoire racine du projet, utilisez la commande suivante pour exécuter le conteneur de test :

docker-compose -f docker-compose.test.yml up

Cette commande démarrera les services d'application et de base de données et exécutera la commande de test.

4. Intégration continue automatisée

Le but de l'intégration continue est de fusionner rapidement et fréquemment les modifications de code des développeurs dans le code principal et d'effectuer des builds et des tests automatisés. Vous pouvez utiliser des outils tels que Jenkins et GitLab CI pour mettre en œuvre une intégration continue automatisée.

Prenons Jenkins comme exemple, créez un fichier nommé Jenkinsfile et ajoutez l'exemple de code suivant :

pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                sh 'docker build -t my-app .'
            }
        }
        stage('Test') {
            steps {
                sh 'docker-compose -f docker-compose.test.yml up'
            }
        }
    }
}

Ce Jenkinsfile définit un pipeline Jenkins qui contient deux étapes : construire et tester. Exécutez la commande docker build命令构建Docker镜像，在测试阶段执行docker-compose pendant la phase de construction pour démarrer le conteneur de test.

Ajoutez le fichier Jenkinsfile au répertoire racine du projet et configurez le serveur Jenkins pour une intégration continue automatisée.

2. Déploiement continu

Le déploiement continu fait référence au déploiement automatique du code dans l'environnement de production après avoir terminé l'intégration continue. L'utilisation de Docker pour un déploiement continu peut grandement simplifier le processus de déploiement.

1. Créer une image Docker

À l'aide du fichier Docker créé lors des étapes précédentes, créez une image Docker contenant le code de l'application.

2. Écriture du fichier docker-compose.yml

Créez un fichier appelé docker-compose.yml dans le répertoire racine du projet et ajoutez l'exemple de code suivant :

version: '3'
services:
  app:
    image: my-app:latest
    restart: always
    ports:
      - 80:3000

Ce fichier docker-compose.yml demande à Docker d'exécuter un service d'application et utilisez l'image my-app qui vient d'être créée comme image de base. De plus, le mappage des ports et d'autres services peuvent être configurés.

3. Déployer l'application

Utilisez la commande suivante pour déployer l'application dans l'environnement de production :

docker-compose up -d

Cette commande démarrera le service d'application en arrière-plan et l'exposera au port 80 de l'hôte.

Ci-dessus sont les étapes spécifiques et les exemples de code sur la façon d'utiliser Docker pour une intégration continue et un déploiement continu. Grâce à Docker, vous pouvez simplifier le processus de configuration et de déploiement de l'environnement, améliorer l'efficacité du développement et la fiabilité des applications.

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!