Laksanakan aplikasi kontena menggunakan Spring Boot dan Kubernetes

Dengan perkembangan teknologi pengkomputeran awan, aplikasi kontena telah menjadi kaedah penting untuk mengatur dan mengurus aplikasi. Apabila aliran ini berkembang, ramai pembangun memilih untuk menggunakan rangka kerja Spring Boot dan Kubernetes, alat penjadualan kontena, dalam proses pembelajaran dan menggunakan aplikasi kontena. Artikel ini akan memperkenalkan cara menggunakan Spring Boot dan Kubernetes untuk melaksanakan aplikasi kontena dengan mudah.

Apakah Spring Boot?

Spring Boot ialah rangka kerja pembangunan berdasarkan rangka Spring, yang memudahkan proses pembangunan aplikasi Spring melalui pengkapsulan dan konfigurasi automatik. Menggunakan mekanisme konfigurasi automatik Spring Boot, pembangun tidak lagi perlu mengkonfigurasi banyak komponen aplikasi secara manual, sebaliknya, mereka boleh melengkapkan permulaan dan suntikan pelbagai komponen melalui anotasi mudah. Oleh itu, Spring Boot boleh mengurangkan jumlah menulis kod perniagaan dan fail konfigurasi, meningkatkan kecekapan pembangunan.

Apakah itu Kubernetes?

Kubernetes ialah sistem penjadualan kontena sumber terbuka yang boleh menskala dan mengurus persekitaran aplikasi yang sedang berjalan secara automatik, membolehkan pembangun menumpukan pada pembangunan dan keluaran aplikasi. Kubernetes menyediakan pelbagai API dan alatan untuk membantu pembangun mengautomasikan penggunaan, menjalankan, penskalaan dan penemuan perkhidmatan aplikasi dalam bekas.

Langkah asas untuk melaksanakan aplikasi kontena menggunakan Spring Boot dan Kubernetes

Mari perkenalkan secara ringkas langkah asas untuk melaksanakan aplikasi kontena menggunakan Spring Boot dan Kubernetes.

Langkah 1: Tulis aplikasi Spring Boot

Dalam Spring Boot, kita hanya perlu menulis kelas Java yang mudah dan menambah beberapa anotasi untuk mencipta aplikasi. Di bawah ialah contoh kod mudah untuk mencipta aplikasi web Spring Boot minimalis.

@RestController
public class HelloController {
    
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
    
    public static void main(String[] args) {
        SpringApplication.run(HelloController.class, args);
    }
}

Dalam kod di atas, kami menggunakan anotasi @RestController untuk mengenal pasti kelas pengawal dan menulis kaedah hello() dalam kelas pengawal untuk mengendalikan permintaan GET. Dalam kaedah main(), kami memanggil SpringApplication.run() untuk memulakan aplikasi. Program ringkas ini boleh mendengar port 8080 dan menyediakan antara muka http /hello, mengembalikan hasil rentetan "Hello, World!"

Langkah 2: Buat bekas Docker

Selepas menulis aplikasi, kita boleh menggunakan Docker untuk mencipta bekas. Docker ialah alat untuk mencipta dan mengurus bekas, yang membolehkan pembangun merangkum aplikasi, persekitaran dan kebergantungan dalam bekas mudah alih untuk penggunaan dan ujian yang mudah.

Untuk mencipta bekas Docker, kita perlu menulis fail Dockerfile yang mentakrifkan proses pembinaan imej aplikasi. Di bawah ialah contoh Dockerfile yang mudah.

FROM openjdk:11-jdk-slim
COPY target/myapp.jar /app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Dalam kod di atas, kami membina bekas baharu berdasarkan imej openjdk:11-jdk-slim, salin pakej balang boleh laku aplikasi ke dalam bekas dan laksanakan balang ini apabila bekas itu memulakan Beg.

Langkah 3: Gunakan Kubernetes untuk menggunakan aplikasi

Selepas bekas Docker dicipta, kita perlu menggunakan Kubernetes untuk menggunakan kontena. Kubernetes menyediakan banyak jenis objek untuk mentakrif dan mengurus pelbagai sumber dan komponen aplikasi.

Untuk aplikasi di atas, kita boleh menggunakan objek Deployment untuk mentakrifkan penggunaan aplikasi dan bilangan salinannya. Kami boleh menggunakan objek Perkhidmatan untuk mentakrifkan kaedah akses penemuan perkhidmatan aplikasi, supaya aplikasi boleh bertukar dengan lancar antara nod yang berbeza. Di bawah ialah contoh fail penggunaan Kubernetes yang mudah.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp
          image: myapp:latest
          ports:
            - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
    - name: http
      port: 80
      targetPort: 8080
  type: LoadBalancer

Dalam kod di atas, kami mentakrifkan objek Deployment, tetapkan bilangan salinan aplikasi kepada 3 dan tentukan imej yang dijalankan dalam bekas sebagai myapp:latest. Kami juga menentukan objek Perkhidmatan, memetakan port 80 kepada port 8080 bekas dan menetapkan kaedah akses kepada jenis LoadBalancer.

Selepas menggunakan aplikasi menggunakan Kubernetes, kami boleh mengakses aplikasi dengan mengakses alamat IP luaran objek Perkhidmatan.

Ringkasan

Dengan menggunakan Spring Boot dan Kubernetes, kami boleh menyimpan, menggunakan dan mengurus aplikasi dengan mudah. Spring Boot menyediakan rangka kerja pembangunan aplikasi mudah untuk membantu pembangun membuat aplikasi dengan cepat, manakala Kubernetes menyediakan alatan pengurusan kontena yang berkuasa untuk memudahkan penggunaan dan penyelenggaraan aplikasi.

Atas ialah kandungan terperinci Laksanakan aplikasi kontena menggunakan Spring Boot dan Kubernetes. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!