Verwenden Sie Docker, um Spring Boot-Anwendungen zu containerisieren und so eine kontinuierliche Integration und kontinuierliche Bereitstellung zu erreichen

Verwenden Sie Docker, um Spring Boot-Anwendungen zu containerisieren und so eine kontinuierliche Integration und kontinuierliche Bereitstellung zu erreichen.

Docker ist eine Open-Source-Containerisierungsplattform, die Anwendungen und ihre abhängigen Ressourcen in einen unabhängigen Container packen und durch Spiegelung bereitgestellt und ausgeführt werden kann . Es bietet eine leichte, schnelle und tragbare Lösung für die Erstellung und Bereitstellung moderner Anwendungen.

Spring Boot ist ein Framework für die schnelle Entwicklung, das eine einfache und skalierbare Möglichkeit zum Erstellen von Java-Anwendungen bietet. Durch die Kombination von Docker und Spring Boot können wir das Ziel erreichen, Anwendungen schnell bereitzustellen, zu skalieren und zu verwalten.

In diesem Artikel wird erläutert, wie Sie Docker zum Containerisieren von Spring Boot-Anwendungen verwenden, um kontinuierliche Integrations- und kontinuierliche Bereitstellungsprozesse zu implementieren, und entsprechende Codebeispiele bereitstellen.

1. Vorbereitung
   Bevor Sie beginnen, stellen Sie sicher, dass Sie Docker und die Java-Entwicklungsumgebung installiert haben und über grundlegende Erfahrung in der Entwicklung von Spring Boot-Anwendungen verfügen.
2. Erstellen Sie eine Spring Boot-Anwendung.
   Zuerst müssen wir eine einfache Spring Boot-Anwendung erstellen. Sie können Spring Initializr (https://start.spring.io/) verwenden, um schnell ein neues Spring Boot-Projekt zu erstellen, oder ein vorhandenes Spring Boot-Projekt verwenden.

Hier erstellen wir eine einfache Hello World-Anwendung wie unten gezeigt:

@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);
    }
}

Dieser Code erstellt einen einfachen Spring MVC-Controller, der beim Zugriff auf die Root-Pfadinformationen ein „Hallo, Docker!“ zurückgibt.

3. Docker-Image erstellen
   Als nächstes müssen wir ein Image erstellen, das von Docker bereitgestellt werden kann. Dazu müssen wir eine Docker-Datei erstellen, um die Build-Regeln für das Image zu definieren.

Erstellen Sie eine Datei mit dem Namen Dockerfile im Stammverzeichnis des Projekts und fügen Sie den folgenden Inhalt hinzu:

# 使用一个基础的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"]

Das obige Dockerfile verwendet das auf Alpine Linux basierende Java 8-Image als Basisimage. Kopieren Sie dann das erstellte JAR-Paket in den Container und führen Sie die Anwendung über die ENTRYPOINT-Anweisung aus.

Der Befehl zum Erstellen des Images lautet wie folgt:

$ docker build -t spring-boot-demo .

Nachdem das Image erstellt wurde, können Sie mit dem folgenden Befehl überprüfen, ob der Build erfolgreich war:

$ docker images

Sie sollten ein Image mit dem Namen spring-boot sehen können -Demo.

4. Docker-Container ausführen
   Nachdem wir das Image haben, können wir Docker-Container basierend auf dem Image erstellen und ausführen.

Führen Sie den folgenden Befehl aus, um den Container zu starten:

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

Unter diesen bedeutet der Parameter -d, dass der Container im Hintergrund ausgeführt wird, und der Parameter -p bedeutet, den 8080-Port des Hosts dem 8080-Port des Containers zuzuordnen .

Überprüfen Sie, ob der Container erfolgreich gestartet wurde. Sie können den Ausführungsstatus des Containers mit dem folgenden Befehl überprüfen:

$ docker ps

Wenn Sie sehen, dass der Container mit dem Namen spring-boot-demo ausgeführt wird, bedeutet dies, dass der Container erfolgreich gestartet wurde .

5. Updates bereitstellen
   Wenn die Anwendung über neue Updates verfügt, können wir das Update und die Bereitstellung der Anwendung mithilfe der folgenden Schritte abschließen.

Aktualisieren Sie zunächst den Anwendungscode lokal und erstellen Sie das Image neu:

$ docker build -t spring-boot-demo .

Dann stoppen und löschen Sie den alten Container:

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

Danach führen Sie den neuen Container erneut aus:

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

6. Kontinuierliche Integration und kontinuierliche Bereitstellung
   Die Die oben genannten Schritte können zum Erstellen und Bereitstellen der Anwendung manuell ausgeführt werden. Bei umfangreichen und häufigen Aktualisierungen ist dies jedoch offensichtlich ineffizient und fehleranfällig. Daher können wir CI/CD-Tools (wie Jenkins, GitLab CI usw.) verwenden, um eine automatisierte kontinuierliche Integration und kontinuierliche Bereitstellung zu erreichen.

Das Folgende ist ein einfaches Beispiel für die Verwendung von Jenkins:

• Jenkins installieren und konfigurieren
  Befolgen Sie die offizielle Dokumentation von Jenkins, installieren und konfigurieren Sie Jenkins und stellen Sie sicher, dass Jenkins auf den Quellcode und die Build-Umgebung zugreifen kann.
• Erstellen Sie eine Jenkins-Aufgabe.
  Verwenden Sie die Pipeline-Funktion von Jenkins, um eine neue Aufgabe zu erstellen und relevante Parameter wie Quellcode-Warehouse-Adresse, Build-Skript, Auslösemethode usw. zu konfigurieren.
• Konfigurieren Sie den Build-Prozess
  Fügen Sie im Jenkins-Build-Skript den folgenden Inhalt hinzu:

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'
            }
        }
    }
}

Dieses Skript spezifiziert den Build-Prozess und den Update-Bereitstellungsprozess der Anwendung, die entsprechend den tatsächlichen Anforderungen geändert werden können.

• Build auslösen
  Nachdem Sie die Build-Parameter und die Auslösemethode konfiguriert, den Build gespeichert und manuell ausgelöst haben, erstellt Jenkins die Anwendung automatisch entsprechend dem konfigurierten Prozess und stellt sie bereit.

Durch die oben genannten Schritte können wir Docker verwenden, um Spring Boot-Anwendungen zu containerisieren und den Prozess der kontinuierlichen Integration und kontinuierlichen Bereitstellung zu realisieren. Auf diese Weise können wir die Entwicklung, Bereitstellung und Verwaltung von Anwendungen erheblich vereinfachen und die Entwicklungseffizienz und Bereitstellungsflexibilität verbessern.

Ich hoffe, dieser Artikel kann Ihnen als Referenz dienen, damit Sie die kontinuierliche Integration und kontinuierliche Bereitstellung von Docker-Container-Spring-Boot-Anwendungen verstehen und üben können. Ich wünsche Ihnen viel Erfolg in Ihrer Praxis!

Das obige ist der detaillierte Inhalt vonVerwenden Sie Docker, um Spring Boot-Anwendungen zu containerisieren und so eine kontinuierliche Integration und kontinuierliche Bereitstellung zu erreichen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!