introduction

En tant que développement hobby, l'équipe a parlé de la création d'un service Web à l'aide de Spring Boot. Je comprends java, mais ma connaissance de Spring Boot est de 0, j'ai donc essayé de créer une API REST à l'aide de docker. En le créant, j'ai fait référence à l'article suivant.

L'environnement de développement est le suivant

OS: macOS High Sierra
docker: 17.12.0-ce
docker-compose version 1.18.0

Cliquez ici pour la source de cet article

Github watariGIT/boot-get-started

Quoi faire

Le conteneur DB utilise une image MySQL existante
Le conteneur APP crée un fichier Docker et monte le fichier, éliminant ainsi le besoin de créer une nouvelle image à chaque fois que vous créez. --Myadmin container est pour une utilisation facile de MySQL

Construire Spring Boot

Je ne sais pas pourquoi SpringBoot, donc je vais faire RestApi localement en guise de préparation.

Préparation DB

Mettez les données nécessaires dans le conteneur mysql et démarrez-le. Si vous ne le faites pas, le test échouera et vous ne pourrez pas construire. Ce que vous devez faire lors du démarrage du conteneur est la suivante

Si vous créez un fichier sql à l'avance et le montez sur / docker-entrypoint-initdb.d, il sera exécuté au démarrage, alors montez-le. --Créer un sboot utilisateur mysql pour Spring Boot
Lien vers le port 3306 sur localhost

Lorsque ceux-ci sont ajoutés, la commande est la suivante. docker container run -v $(PWD)/sql:/docker-entrypoint-initdb.d -d -e MYSQL_DATABASE=mydb -e MYSQL_USER=sboot -e MYSQL_PASSWORD=sboot -e MYSQL_ROOT_PASSWORD=root-pass -p 3306:3306 -d mysql

Ce sera long, mais supportons-le jusqu'à ce que nous fassions un docker-compose.

Créer build.gradle

SpringBoot semble utiliser gradle pour la gestion des builds et des bibliothèques. Remplissez les éléments requis dans SPRING INITIALIZR et déposez le modèle. Modifiez le fichier build.gradle en haut du répertoire comme suit.

buildscript {
    ext {
        springBootVersion = '1.5.2.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

jar {
    baseName = 'boot-get-started'
    version = '0.0.1-SNAPSHOT'
}

sourceCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    compile('org.springframework.boot:spring-boot-starter-web')
    compile("org.springframework.boot:spring-boot-starter-data-jpa")
    compile("org.springframework.boot:spring-boot-starter-data-rest")
    compile('mysql:mysql-connector-java:6.0.6')
    compileOnly('org.projectlombok:lombok')
    testCompile('org.springframework.boot:spring-boot-starter-test')
}

Il est pratique de remplir la bibliothèque requise dans les dépendances. Je suis content que vous testiez probablement à testCompile. Je veux en savoir plus plus tard.

gradlew clean build termine l'installation de la bibliothèque.

Création d'entité et de référentiel

Créez l'Enttity et Repository pour DB dans src / main / java / com / example. Je ne comprends pas vraiment ce domaine car je viens de copier l 'article de référence. Cette fois, l'objectif principal est de construire l'environnement, je vais donc le diviser.

Création de application.yml

Créez src / main / resources / application.yml. Entrez ici la destination de la connexion DB. Notez que la destination de connexion diffère selon que l'application est exécutée localement ou connectée sur un conteneur.

spring:
  profiles:
    active: localhost
---
spring:
  profiles: localhost
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mydb
    username: sboot
    password: sboot
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
    hibernate:
      ddl-auto: update
  data:
    rest:
      base-path: /api

---
spring:
  profiles: docker
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://dbserver/mydb
    username: sboot
    password: sboot
  jpa:
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
    show-sql: true
    hibernate:
      ddl-auto: update
  data:
    rest:
      base-path: /api

Créez un profil correspondant à localhost et docker et définissez localhost par défaut. Le changement de profil se fait dans DockerFile (décrit plus loin)

Construire

Faites gradlew build avec le conteneur mysql configuré, et si BUILD SUCCESS FUL apparaît, c'est OK. Maintenant que la génération est réussie, il est temps de conteneuriser l'application et de l'exécuter.

Création de DockerFile et Compose

Tout d'abord, créez un DockerFile pour votre application.

# use alpine as base image
FROM ubuntu:16.04

RUN apt-get update
RUN apt-get -y install openjdk-8-jdk
ENV JAVA_HOME /usr/lib/jvm/java-8-openjdk-amd64

# recommended by spring boot
VOLUME /tmp

# create directory for application
RUN mkdir /app
WORKDIR /app

# jar target
ENV JAR_TARGET "boot-get-started-0.0.1-SNAPSHOT.jar"

# set entrypoint to execute spring boot application
ENTRYPOINT ["sh","-c","java -jar -Dspring.profiles.active=docker build/libs/${JAR_TARGET}"]

Passez au profil décrit dans ʻapplication.yml avec -Dspring.profiles.active = docker de ʻENTRY POINT. --Monter le fichier créé lors de l'exécution sur / app. --Exécute le fichier spécifié dans JAR_TARGET. (Par défaut "boot-get-started-0.0.1-SNAPSHOT.jar")

Ensuite, écrivez docker-compose.yml qui combine les conteneurs db, app et phpmyadmin.

version: '2'
services:

    dbserver:
        image: mysql
        volumes:
            - ./sql:/docker-entrypoint-initdb.d
            - mysql-db:/var/lib/mysql
        environment:
            MYSQL_DATABASE: mydb
            MYSQL_USER: sboot
            MYSQL_PASSWORD: sboot
            MYSQL_ROOT_PASSWORD: root
           
    app:
        build: .
        image: watari/boot:0.1.0                            
        depends_on:
            - dbserver
        ports:
            - "8080:8080"
        volumes:
            - .:/app
        environment:
            JAR_TARGET: boot-get-started-0.0.1-SNAPSHOT.jar

    myadmin:
        image: phpmyadmin/phpmyadmin
        depends_on:
            - dbserver
        environment:
            PMA_ARBITRARY: 1
            PMA_HOST: dbserver
            PMA_USER: root
            PMA_PASSWORD: root
        ports:
            - "1111:80"

volumes:
    mysql-db:
        driver: local

Courir

Il peut être exécuté avec docker-compose up. La première fois que vous devez créer une image à partir d'un fichier Docker, vous devez ajouter l'option --build. Après avoir lancé le conteneur et l'avoir exécuté, vérifiez-le avec la commande curl.

$ curl http://localhost:8080/api/users
{
  "_embedded" : {
    "users" : [ {
      "firstName" : "Taro",
      "lastName" : "Yamada",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/api/users/1"
        },
        "user" : {
          "href" : "http://localhost:8080/api/users/1"
        }
      }
    }, {
      "firstName" : "Hanako",
      "lastName" : "Tanaka",
      "_links" : {
        "self" : {
          "href" : "http://localhost:8080/api/users/2"
        },
        "user" : {
          "href" : "http://localhost:8080/api/users/2"
        }
      }
    } ]
  },
  "_links" : {
    "self" : {
      "href" : "http://localhost:8080/api/users"
    },
    "profile" : {
      "href" : "http://localhost:8080/api/profile/users"
    }
  }
}

en conclusion

Je n'ai aucune connaissance de Spring Boot, mais j'ai pu facilement créer un environnement en utilisant un conteneur. Cependant, comme je fais la construction localement, j'ai l'impression que c'est quelque chose, alors pourquoi ne pas laisser le conteneur faire également la construction? Je pense aussi. Aussi, je développe maintenant sur emacs, mais je pense qu'il est nécessaire de bien le combiner lors du développement dans un environnement de développement intégré tel qu'eclipse à l'avenir (je n'ai aucun savoir-faire ici). Je pense que je vais l'utiliser comme point de départ pour les essais et erreurs.

[JAVA] Créer un environnement de développement Spring Boot avec docker