Erstellen Sie cloudnative Containeranwendungen mit Docker und Spring Boot

Verwenden Sie Docker und Spring Boot, um containerisierte cloudnative Anwendungen zu erstellen.

Eine cloudnative Anwendung ist eine Anwendung, die durch Containerisierung und Microservice-Architektur erstellt wurde und über hohe Skalierbarkeit, hohe Flexibilität und hohe Zuverlässigkeit verfügt. Als derzeit beliebteste Containertechnologie kann Docker uns dabei helfen, eine schnelle Bereitstellung und einen schnellen Betrieb von Cloud-nativen Anwendungen zu erreichen. Mit Spring Boot als leichtgewichtigem Java-Entwicklungsframework können wir Microservices schneller und bequemer erstellen.

In diesem Artikel wird erläutert, wie Sie Docker und Spring Boot zum Erstellen von cloudnativen Containeranwendungen verwenden, und es werden spezifische Codebeispiele bereitgestellt.

Zuerst müssen wir Docker und die Java-Entwicklungsumgebung installieren. Docker kann von der offiziellen Website heruntergeladen und entsprechend den Anweisungen installiert werden, während die Java-Entwicklungsumgebung von der offiziellen Website von Oracle heruntergeladen und installiert werden kann.

Als nächstes erstellen wir ein neues Spring Boot-Projekt. Sie können IDE-Tools wie IntelliJ IDEA oder Eclipse verwenden oder Spring Initializr verwenden, um schnell ein neues Projekt zu erstellen. Beim Erstellen eines Projekts müssen Sie Web und Docker als Abhängigkeiten auswählen und zugehörige Projektinformationen festlegen.

Nachdem wir das Spring Boot-Projekt erstellt haben, können wir mit dem Schreiben von Code beginnen. Fügen Sie zunächst die Annotation @EnableDocker in der Hauptklasse des Projekts hinzu, um die Docker-Unterstützung zu aktivieren.

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

Im obigen Code verwenden wir die Annotation @EnableDocker, um die Docker-Unterstützung zu aktivieren und ein RestTemplate-Bean zum Senden von HTTP-Anfragen zu definieren.

Dann können wir eine einfache RESTful-Schnittstelle erstellen. Fügen Sie in der Controller-Klasse des Projekts die Annotation @RestController hinzu und definieren Sie eine einfache GET-Anforderungsschnittstelle.

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

Im obigen Code verwenden wir die Abhängigkeitsinjektion von Spring, um eine Instanz von RestTemplate zu injizieren und sie in der GET-Anforderungsschnittstelle zum Senden von HTTP-Anforderungen zu verwenden.

Als nächstes müssen wir eine Docker-Datei erstellen, um das Docker-Image zu erstellen. Erstellen Sie eine Datei mit dem Namen Dockerfile im Stammverzeichnis des Projekts und fügen Sie den folgenden Inhalt hinzu:

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

In der obigen Docker-Datei haben wir openjdk:8 als Basis-Image verwendet und die erstellte JAR-Datei in das Image kopiert. Verwenden Sie dann die ENTRYPOINT-Direktive, um den Befehl anzugeben, der beim Start des Docker-Containers ausgeführt werden soll.

Schließlich können wir den folgenden Befehl verwenden, um das Docker-Image zu erstellen und den Container auszuführen:

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

Im obigen Befehl verwenden wir zunächst den Docker-Build-Befehl, um ein Docker-Image mit dem Namen cloud-native-app zu erstellen. Verwenden Sie dann den Befehl „docker run“, um einen Docker-Container basierend auf dem Image auszuführen und den 8080-Port des Containers dem 8080-Port des Hosts zuzuordnen.

Jetzt können wir unsere Cloud-native Anwendung testen, indem wir auf http://localhost:8080/api/hello zugreifen. Wenn alles in Ordnung ist, wird der Antwortinhalt zurückgegeben.

In der Einleitung dieses Artikels haben wir gelernt, wie man Docker und Spring Boot zum Erstellen containerisierter Cloud-nativer Anwendungen verwendet, und detaillierte Codebeispiele bereitgestellt. Ich hoffe, dieser Artikel kann Ihnen dabei helfen, cloudnative Technologien besser für die Entwicklung und Bereitstellung von Anwendungen einzusetzen.

Das obige ist der detaillierte Inhalt vonErstellen Sie cloudnative Containeranwendungen mit Docker und Spring Boot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!