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

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

Cliquez ici pour la source de cet article

Quoi faire

スクリーンショット 2018-03-04 22.02.53.png

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

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}"]

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.

Recommended Posts

Créer un environnement de développement Spring Boot avec docker
Créer un environnement de développement Spring Boot-gradle-mysql avec Docker
Créez un environnement Vue3 avec Docker!
Création d'un environnement de développement Spring Boot dans Vagrant
Créer un environnement de développement PureScript avec Docker
Créer un environnement de développement Wordpress avec Docker
J'ai essayé de créer un environnement de développement padrino avec Docker
Créez un site Web avec Spring Boot + Gradle (jdk1.8.x)
[Memo] Créez facilement un environnement CentOS 8 avec Docker
Créez une application de recherche simple avec Spring Boot
Créer un environnement Spring Boot avec Windows + VS Code
Créer un serveur API Web avec Spring Boot
Créer un micro service avec Spring Boot
Créez un projet de développement d'application Spring Boot avec la commande cURL + tar
Créer un environnement de développement d'applications Web Java avec Docker pour Mac Part2
[Note] Créez un environnement Java à partir de zéro avec docker
Créer un environnement de développement Chisel avec Windows10 + WSL2 + VScode + Docker
Créer un environnement Node.js avec Docker
Créez une application avec Spring Boot 2
Créer un environnement de vérification SolrCloud avec Docker
Créez une application avec Spring Boot
Créez un environnement de développement pour créer des applications Ruby on Jets + React avec Docker
J'ai essayé de créer un environnement de développement java8 avec Chocolatey
J'ai créé un environnement de développement avec rails6 + docker + postgreSQL + Materialise.
Créez un environnement de développement «Spring Thorough Introduction» avec IntelliJ IDEA
Créez rapidement un environnement Web à l'aide de Docker
Construction de l'environnement de développement Laravel avec Docker (Mac)
Construire un environnement Rails 6 + MySQL avec Docker compose
Créez un lot à la demande simple avec Spring Batch
Créons un environnement de développement Java (mise à jour)
[Docker] Créez un environnement Node.js + express + webpack avec Docker
Démarrez le développement d'applications Web avec Spring Boot
Construction d'un environnement de développement simple Docker + Django
[SAP] Créez un environnement de développement avec NW AS ABAP Developer Edition (1)
Procédure de création d'un environnement de développement d'applications Rails avec Docker [Rails, MySQL, Docker]
J'ai essayé de créer un environnement de développement Spring MVC sur Mac
Créer un environnement de développement pour Django + MySQL + nginx avec Docker Compose
Créer un environnement de développement pour Docker + Rails6 + Postgresql
Commençons par Java - Créez un environnement de développement ②
Commençons par Java - Créez un environnement de développement ①
Créez instantanément un environnement Privoxy + Tor à l'aide de Docker
[Windows] [IntelliJ] [Java] [Tomcat] Créer un environnement pour Tomcat 9 avec IntelliJ
Créer un environnement Laravel / Docker avec VSCode devcontainer
Créez une application Spring Boot à l'aide d'IntelliJ IDEA
Environnement de développement-développement Spring Boot-
Une note sur l'essai d'Oracle 11g + Spring Boot avec Vagrant + Docker compose
[Copier et coller] Créez un environnement de développement Laravel avec Docker Compose, partie 2
Construction de l'environnement de développement Simple Docker Compose + Django
Créez des projets Spring Boot par environnement avec Gradle
Comment créer un environnement de développement Ruby on Rails avec Docker (Rails 6.x)
Créez une application CRUD avec Spring Boot 2 + Thymeleaf + MyBatis
Créez un environnement de développement local pour les didacticiels Rails avec Docker (Rails 6 + PostgreSQL + Webpack)
[Win10] Créer un environnement de développement JSF avec NetBeans
Créez votre propre utilitaire avec Thymeleaf avec Spring Boot