Utilisez Docker pour conteneuriser les applications Spring Boot afin d'obtenir une intégration et un déploiement continus

Utilisez Docker pour conteneuriser les applications Spring Boot afin d'obtenir une intégration et un déploiement continus

Docker est une plate-forme de conteneurisation open source qui peut regrouper les applications et leurs ressources dépendantes dans un conteneur indépendant et peut être utilisée via la mise en miroir. Être déployée et exécutée . Il fournit une solution légère, rapide et portable pour créer et déployer des applications modernes.

Spring Boot est un framework de développement rapide qui fournit un moyen simple et évolutif de créer des applications Java. En combinant Docker et Spring Boot, nous pouvons atteindre l'objectif de déployer, faire évoluer et gérer rapidement les applications.

Cet article expliquera comment utiliser Docker pour conteneuriser les applications Spring Boot afin de mettre en œuvre des processus d'intégration continue et de déploiement continu, et fournira des exemples de code correspondants.

1. Préparation
   Avant de commencer, assurez-vous d'avoir installé l'environnement de développement Docker et Java et d'avoir une expérience de base en développement d'applications Spring Boot.
2. Créer une application Spring Boot
   Tout d'abord, nous devons créer une application Spring Boot simple. Vous pouvez utiliser Spring Initializr (https://start.spring.io/) pour créer rapidement un nouveau projet Spring Boot ou utiliser un projet Spring Boot existant.

Ici, nous créons une application Hello World simple comme indiqué ci-dessous :

@Controller
public class HelloWorldController {
  
    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, Docker!");
        return "hello";
    }
  
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldController.class, args);
    }
}

Ce code crée un contrôleur Spring MVC de base qui, lors de l'accès au chemin racine, renvoie une information "Bonjour, Docker !"

3. Créer une image Docker
   Ensuite, nous devons créer une image qui peut être déployée par Docker. Pour ce faire, nous devons créer un Dockerfile pour définir les règles de construction de l'image.

Créez un fichier nommé Dockerfile dans le répertoire racine du projet et ajoutez le contenu suivant :

# 使用一个基础的Java 8镜像
FROM openjdk:8-jdk-alpine

# 将应用的jar包添加到容器中
COPY target/demo-0.0.1-SNAPSHOT.jar /app.jar

# 暴露8080端口
EXPOSE 8080

# 运行jar包
ENTRYPOINT ["java","-jar","/app.jar"]

Le Dockerfile ci-dessus utilise l'image Java 8 basée sur Alpine Linux comme image de base. Ensuite, copiez le package jar construit dans le conteneur et exécutez l'application via l'instruction ENTRYPOINT.

La commande pour créer l'image est la suivante :

$ docker build -t spring-boot-demo .

Une fois l'image créée, vous pouvez utiliser la commande suivante pour vérifier si la construction a réussi :

$ docker images

Vous devriez pouvoir voir une image nommée spring-boot -démo.

4. Exécuter des conteneurs Docker
   Une fois que nous avons l'image, nous pouvons créer et exécuter des conteneurs Docker basés sur l'image.

Exécutez la commande suivante pour démarrer le conteneur :

$ docker run -d -p 8080:8080 spring-boot-demo

Parmi eux, le paramètre -d signifie exécuter le conteneur en arrière-plan, et le paramètre -p signifie mapper le port 8080 de l'hôte au port 8080 du conteneur .

Vérifiez si le conteneur a démarré avec succès. Vous pouvez vérifier l'état d'exécution du conteneur via la commande suivante :

$ docker ps

Si vous voyez que le conteneur nommé spring-boot-demo est en cours d'exécution, cela signifie qu'il a démarré avec succès. .

5. Déploiement des mises à jour
   Lorsque l'application dispose de nouvelles mises à jour, nous pouvons terminer la mise à jour et le déploiement de l'application en suivant les étapes suivantes.

Tout d'abord, mettez à jour le code de l'application localement et reconstruisez l'image :

$ docker build -t spring-boot-demo .

Ensuite, arrêtez et supprimez l'ancien conteneur :

$ docker stop [CONTAINER_ID]
$ docker rm [CONTAINER_ID]

Après cela, exécutez à nouveau le nouveau conteneur :

$ docker run -d -p 8080:8080 spring-boot-demo

6. Intégration continue et déploiement continu
   Le Les étapes ci-dessus peuvent être effectuées manuellement pour créer et déployer l'application, mais pour les mises à jour fréquentes et à grande échelle, cela est évidemment inefficace et sujet aux erreurs. Par conséquent, nous pouvons utiliser des outils CI/CD (tels que Jenkins, GitLab CI, etc.) pour réaliser une intégration continue automatisée et un déploiement continu.

Ce qui suit est un exemple simple utilisant Jenkins :

• Installez et configurez Jenkins
  Suivez la documentation officielle de Jenkins, installez et configurez Jenkins, et assurez-vous que Jenkins peut accéder au code source et à l'environnement de construction.
• Créer une tâche Jenkins
  Utilisez la fonction Pipeline de Jenkins pour créer une nouvelle tâche et configurer les paramètres pertinents, tels que l'adresse de l'entrepôt du code source, le script de construction, la méthode de déclenchement, etc.
• Configurer le processus de build
  Dans le script de build Jenkins, ajoutez le contenu suivant :

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        stage('Build Docker Image') {
            steps {
                sh 'docker build -t spring-boot-demo .'
            }
        }
        stage('Deploy') {
            steps {
                sh 'docker stop spring-boot-demo'
                sh 'docker rm spring-boot-demo'
                sh 'docker run -d -p 8080:8080 --name spring-boot-demo spring-boot-demo'
            }
        }
    }
}

Ce script spécifie le processus de build de l'application et le processus de déploiement des mises à jour, qui peuvent être modifiés en fonction des besoins réels.

• Trigger build
  Après avoir configuré les paramètres de build et la méthode de déclenchement, enregistré et déclenché manuellement la build, Jenkins construira et déploiera automatiquement l'application selon le processus configuré.

Grâce aux étapes ci-dessus, nous pouvons utiliser Docker pour conteneuriser les applications Spring Boot et réaliser le processus d'intégration continue et de déploiement continu. De cette manière, nous pouvons grandement simplifier le développement, le déploiement et la gestion des applications et améliorer l'efficacité du développement et la flexibilité du déploiement.

J'espère que cet article pourra vous fournir une référence pour comprendre et pratiquer l'intégration continue et le déploiement continu des applications Spring Boot conteneurisées Docker. Je vous souhaite du succès dans votre pratique!

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!