Gunakan Docker untuk menyimpan aplikasi Spring Boot untuk mencapai penyepaduan berterusan dan penggunaan berterusan

Gunakan Docker untuk menyimpan aplikasi Spring Boot untuk mencapai penyepaduan berterusan dan penggunaan berterusan

Docker ialah platform kontena sumber terbuka yang boleh membungkus aplikasi dan sumber bergantungnya ke dalam bekas bebas, dan boleh digunakan melalui pencerminan Dapatkan digunakan dan berjalan . Ia menyediakan penyelesaian yang ringan, pantas dan mudah alih untuk membina dan menggunakan aplikasi moden.

Spring Boot ialah rangka kerja pembangunan pesat yang menyediakan cara mudah dan berskala untuk membina aplikasi Java. Menggabungkan Docker dan Spring Boot, kami boleh mencapai matlamat untuk menggunakan, menskala dan mengurus aplikasi dengan cepat.

Artikel ini akan memperkenalkan cara menggunakan Docker untuk menyimpan aplikasi Spring Boot untuk melaksanakan penyepaduan berterusan dan proses penggunaan berterusan, serta menyediakan contoh kod yang sepadan.

1. Persediaan
   Sebelum anda bermula, pastikan anda telah memasang Docker dan persekitaran pembangunan Java, dan mempunyai pengalaman asas pembangunan aplikasi Spring Boot.
2. Buat aplikasi Spring Boot
   Pertama, kita perlu mencipta aplikasi Spring Boot yang mudah. Anda boleh menggunakan Spring Initializr (https://start.spring.io/) untuk mencipta projek Spring Boot baharu dengan pantas atau menggunakan projek Spring Boot sedia ada.

Di sini, kami mencipta aplikasi Hello World yang ringkas seperti yang ditunjukkan di bawah:

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

Kod ini mencipta pengawal MVC Spring asas yang, apabila mengakses laluan akar, mengembalikan maklumat "Hello, Docker!"

3. Bina Imej Docker
   Seterusnya, kita perlu membina imej yang boleh digunakan oleh Docker. Untuk melakukan ini, kita perlu mencipta Dockerfile untuk menentukan peraturan binaan untuk imej.

Buat fail bernama Dockerfile dalam direktori akar projek dan tambah kandungan berikut:

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

Dockerfile di atas menggunakan imej Java 8 berdasarkan Alpine Linux sebagai imej asas. Kemudian, salin pakej balang yang dibina ke dalam bekas dan jalankan aplikasi melalui arahan ENTRYPOINT.

Arahan untuk membina imej adalah seperti berikut:

$ docker build -t spring-boot-demo .

Selepas imej dibina, anda boleh menggunakan arahan berikut untuk mengesahkan sama ada binaan itu berjaya:

$ docker images

Anda sepatutnya dapat melihat imej bernama spring-boot -demo.

4. Menjalankan Bekas Docker
   Selepas kami mempunyai imej, kami boleh mencipta dan menjalankan bekas Docker berdasarkan imej.

Jalankan arahan berikut untuk memulakan bekas:

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

Antaranya, parameter -d bermaksud menjalankan bekas di latar belakang, dan parameter -p bermaksud memetakan port 8080 hos ke port 8080 kontena .

Sahkan sama ada bekas berjaya dimulakan Anda boleh menyemak status berjalan kontena melalui arahan berikut:

$ docker ps

Jika anda dapat melihat bahawa bekas bernama spring-boot-demo sedang berjalan, ini bermakna bekas telah berjaya dimulakan. .

5. Menggunakan kemas kini
   Apabila aplikasi mempunyai kemas kini baharu, kami boleh melengkapkan kemas kini dan penggunaan aplikasi melalui langkah berikut.

Mula-mula, kemas kini kod aplikasi secara setempat dan bina semula imej:

$ docker build -t spring-boot-demo .

Kemudian, hentikan dan padamkan bekas lama:

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

Selepas itu, jalankan bekas baharu semula:

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

6. Penyatuan berterusan
   Penyertaan berterusan
langkah di atas boleh dilakukan secara manual untuk membina dan menggunakan aplikasi, tetapi untuk kemas kini berskala besar dan kerap, ini jelas tidak cekap dan terdedah kepada ralat. Oleh itu, kami boleh menggunakan alat CI/CD (seperti Jenkins, GitLab CI, dll.) untuk mencapai penyepaduan berterusan automatik dan penggunaan berterusan.

• 
  Pasang dan konfigurasikan Jenkins
Ikuti dokumentasi rasmi Jenkins, pasang dan konfigurasi Jenkins, dan pastikan Jenkins boleh mengakses kod sumber dan persekitaran binaan.
• 
  Buat tugas Jenkins
Gunakan fungsi Pipeline Jenkins untuk mencipta tugas baharu dan mengkonfigurasikan parameter yang berkaitan, seperti alamat gudang kod sumber, skrip binaan, kaedah pencetus, dsb.
• 
  Konfigurasikan proses binaan
Dalam skrip binaan Jenkins, tambahkan kandungan berikut:

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

• 
  Trigger build
Selepas mengkonfigurasi parameter binaan dan kaedah pencetus, simpan dan pencetus binaan secara manual, Jenkins akan membina dan menggunakan aplikasi secara automatik mengikut proses yang dikonfigurasikan.

Atas ialah kandungan terperinci Gunakan Docker untuk menyimpan aplikasi Spring Boot untuk mencapai penyepaduan berterusan dan penggunaan berterusan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!