Bina aplikasi asli awan dalam kontena menggunakan Docker dan Spring Boot

Gunakan Docker dan Spring Boot untuk membina aplikasi asli awan dalam kontena

Aplikasi asli awan ialah aplikasi yang dibina melalui seni bina kontena dan perkhidmatan mikro, dengan ciri berskala tinggi, fleksibiliti tinggi dan kebolehpercayaan yang tinggi. Sebagai teknologi kontena paling popular pada masa ini, Docker boleh membantu kami mencapai penggunaan pantas dan pengendalian aplikasi asli awan. Spring Boot, sebagai rangka kerja pembangunan Java yang ringan, membolehkan kami membina perkhidmatan mikro dengan lebih pantas dan lebih mudah.

Artikel ini akan memperkenalkan cara menggunakan Docker dan Spring Boot untuk membina aplikasi cloud-asli kontena, dan memberikan contoh kod khusus.

Pertama, kita perlu memasang Docker dan persekitaran pembangunan Java. Docker boleh dimuat turun dari laman web rasmi dan dipasang mengikut arahan, manakala persekitaran pembangunan Java boleh dimuat turun dari laman web rasmi Oracle dan dipasang.

Seterusnya, kami mencipta projek Spring Boot baharu. Anda boleh menggunakan alatan IDE seperti IntelliJ IDEA atau Eclipse, atau anda boleh menggunakan Spring Initializr untuk mencipta projek baharu dengan pantas. Apabila membuat projek, anda perlu memilih Web dan Docker sebagai kebergantungan dan menetapkan maklumat projek yang berkaitan.

Selepas mencipta projek Spring Boot, kita boleh mula menulis kod. Mula-mula, tambah anotasi @EnableDocker dalam kelas utama projek untuk mendayakan sokongan Docker.

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient
@EnableDocker
public class CloudNativeApplication {

    public static void main(String[] args) {
        SpringApplication.run(CloudNativeApplication.class, args);
    }

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

Dalam kod di atas, kami menggunakan anotasi @EnableDocker untuk mendayakan sokongan Docker dan mentakrifkan RestTemplate Bean untuk menghantar permintaan HTTP.

Kemudian, kita boleh mencipta antara muka RESTful yang mudah. Dalam kelas pengawal projek, tambah anotasi @RestController dan tentukan antara muka permintaan GET yang mudah.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/api")
public class ApiController {

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/hello")
    public String hello() {
        String response = restTemplate.getForObject("http://other-service/api/greeting", String.class);
        return "Hello from Cloud Native App. Response from other-service: " + response;
    }
}

Dalam kod di atas, kami menggunakan suntikan kebergantungan Spring untuk menyuntik contoh RestTemplate dan menggunakannya dalam antara muka permintaan GET untuk menghantar permintaan HTTP.

Seterusnya, kita perlu mencipta fail Docker untuk membina imej Docker. Cipta fail bernama Dockerfile dalam direktori akar projek dan tambah kandungan berikut:

FROM openjdk:8
COPY target/cloud-native-app.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Dalam Dockerfile di atas, kami menggunakan openjdk:8 sebagai imej asas dan menyalin fail jar terbina ke imej. Kemudian, gunakan arahan ENTRYPOINT untuk menentukan arahan untuk dijalankan apabila bekas Docker bermula.

Akhir sekali, kita boleh menggunakan arahan berikut untuk membina imej Docker dan menjalankan bekas:

docker build -t cloud-native-app .
docker run -d -p 8080:8080 cloud-native-app

Dalam arahan di atas, kita mula-mula menggunakan arahan binaan docker untuk membina imej Docker bernama cloud-native-app. Kemudian, gunakan arahan docker run untuk menjalankan bekas Docker berdasarkan imej dan petakan port 8080 kontena ke port 8080 hos.

Kini, kami boleh menguji aplikasi asli awan kami dengan mengakses http://localhost:8080/api/hello. Jika semuanya baik-baik saja, anda akan melihat kandungan respons dikembalikan.

Melalui pengenalan artikel ini, kami mempelajari cara menggunakan Docker dan Spring Boot untuk membina aplikasi cloud-asli kontena, dan memberikan contoh kod terperinci. Saya harap artikel ini dapat membantu anda menggunakan teknologi asli awan dengan lebih baik untuk membangunkan dan menggunakan aplikasi.

Atas ialah kandungan terperinci Bina aplikasi asli awan dalam kontena menggunakan Docker dan Spring Boot. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!