Créez des applications cloud natives conteneurisées à l'aide de Docker et Spring Boot

Utilisez Docker et Spring Boot pour créer des applications cloud natives conteneurisées

Une application cloud native est une application construite via la conteneurisation et l'architecture de microservices, avec des fonctionnalités d'évolutivité, de flexibilité et de fiabilité élevées. En tant que technologie de conteneur la plus populaire actuellement, Docker peut nous aider à déployer et à exploiter rapidement des applications cloud natives. Spring Boot, en tant que framework de développement Java léger, nous permet de créer des microservices plus rapidement et plus facilement.

Cet article expliquera comment utiliser Docker et Spring Boot pour créer des applications cloud natives conteneurisées et fournira des exemples de code spécifiques.

Tout d'abord, nous devons installer l'environnement de développement Docker et Java. Docker peut être téléchargé depuis le site officiel et installé selon les instructions, tandis que l'environnement de développement Java peut être téléchargé depuis le site officiel d'Oracle et installé.

Ensuite, nous créons un nouveau projet Spring Boot. Vous pouvez utiliser des outils IDE tels que IntelliJ IDEA ou Eclipse, ou vous pouvez utiliser Spring Initializr pour créer rapidement un nouveau projet. Lors de la création d'un projet, vous devez sélectionner Web et Docker comme dépendances et définir les informations associées au projet.

Après avoir créé le projet Spring Boot, nous pouvons commencer à écrire du code. Tout d’abord, ajoutez l’annotation @EnableDocker dans la classe principale du projet pour activer la prise en charge de 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();
    }
}

Dans le code ci-dessus, nous utilisons l'annotation @EnableDocker pour activer la prise en charge de Docker et définir un RestTemplate Bean pour l'envoi de requêtes HTTP.

Ensuite, nous pouvons créer une interface RESTful simple. Dans la classe de contrôleur du projet, ajoutez l'annotation @RestController et définissez une interface de requête GET simple.

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

Dans le code ci-dessus, nous utilisons l'injection de dépendances de Spring pour injecter une instance de RestTemplate et l'utilisons dans l'interface de requête GET pour envoyer des requêtes HTTP.

Ensuite, nous devons créer un Dockerfile pour construire l'image Docker. Créez un fichier nommé Dockerfile dans le répertoire racine du projet et ajoutez le contenu suivant :

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

Dans le Dockerfile ci-dessus, nous avons utilisé openjdk:8 comme image de base et copié le fichier jar construit dans l'image. Ensuite, utilisez la directive ENTRYPOINT pour spécifier la commande à exécuter au démarrage du conteneur Docker.

Enfin, nous pouvons utiliser la commande suivante pour créer l'image Docker et exécuter le conteneur :

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

Dans la commande ci-dessus, nous utilisons d'abord la commande docker build pour créer une image Docker nommée cloud-native-app. Ensuite, utilisez la commande docker run pour exécuter un conteneur Docker basé sur l'image et mapper le port 8080 du conteneur au port 8080 de l'hôte.

Maintenant, nous pouvons tester notre application cloud native en accédant à http://localhost:8080/api/hello. Si tout va bien, vous verrez le contenu de la réponse renvoyé.

Grâce à l'introduction de cet article, nous avons appris à utiliser Docker et Spring Boot pour créer des applications cloud natives conteneurisées et avons fourni des exemples de code détaillés. J'espère que cet article pourra vous aider à mieux appliquer les technologies cloud natives pour développer et déployer des applications.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!