Aperçu

Ceci est un mémo lors de la création d'un environnement pour développer et exécuter une application Web qui utilise MySQL et Redis avec Java (en utilisant Spring Boot comme cadre) avec Docker CE pour Windows. MySQL et Redis sont des conteneurs qui utilisent l'image officielle, et les applications Web développées avec Spring Boot installent et exécutent OpenJDK dans le conteneur qui utilise l'image officielle de CentOS 7.

Le code source peut être trouvé sur rubytomato / docker-demo-redis.

environnement

Windows 10 Professional
Docker CE for Windows 18.06.0
- Redis 4.0.11
- MySQL 8.0.12
- CentOS 7
  - OpenJDK 1.8.0_181
  - Spring Boot 2.0.4

Créer un environnement d'exécution pour les applications MySQL, Redis et Web

Structure du répertoire du projet

La gestion et l'exécution du conteneur étant effectuées par docker-compose, docker-compose.yml est placé dans le répertoire racine du projet. Les informations sur chaque conteneur sont séparées pour chaque sous-répertoire.

Sous project-root, il y a environ quatre sous-répertoires. Le sous-répertoire demo-redis-spring est le répertoire de projet pour les applications Web qui s'exécutent sur app-server au lieu de conteneurs.

sub directory	description
app-server	Un répertoire qui stocke le Dockerfile et les fichiers associés du conteneur qui exécute l'application Web.
mysql-server	mysql-Un répertoire qui stocke le Dockerfile et les fichiers associés du conteneur qui exécute le serveur.
redis-server	redis-Un répertoire qui stocke le Dockerfile et les fichiers associés du conteneur qui exécute le serveur.
demo-redis-spring	Il s'agit du répertoire de projet de l'application Web qui utilise Spring Boot.

** Structure du répertoire **

/project-root
 |
 +--- docker-compose.yml
 +--- README.md
 |
 +--- /demo-redis-spring
 |      |
 |      +--- pom.xml
 |      |
 |      +--- /src
 |      |      |
 |      |      +--- /main
 |      |      +--- /test
 |      |
 |      +--- /target
 |             |
 |             +--- demo.jar
 |
 +--- /app-server
 |      |
 |      +--- Dockerfile
 |      |
 |      +--- start.sh
 |
 +--- /mysql-server
 |      |
 |      +--- Dockerfile
 |      |
 |      +--- /conf
 |      |      |
 |      |      +--- mysqld.cnf
 |      |
 |      +--- /sql
 |             |
 |             +--- 1_schema.sql
 |             +--- 2_init_memo_data.sql
 |
 +--- /redis-server
        |
        +--- Dockerfile
        |
        +--- /conf
               |
               +--- redis.conf

Conteneur pour serveur MySQL

L'image utilise le MySQL officiel.

library/mysql - Docker Hub

Dockerfile

FROM mysql:8.0.12

COPY ./conf/mysqld.cnf /etc/mysql/conf.d

COPY ./sql/1_schema.sql /docker-entrypoint-initdb.d
COPY ./sql/2_init_memo_data.sql /docker-entrypoint-initdb.d

Configuration

Le contenu de /conf/mysqld.cnf est le suivant. Si vous copiez ce fichier dans /etc/mysql/conf.d dans le conteneur, il sera lu et reflété au démarrage de MySQL.

[mysqld]
character_set_server = utf8mb4
collation_server = utf8mb4_general_ci

log_output = FILE
general_log = 1
log_queries_not_using_indexes = 1
log_slow_admin_statements = 1
log_syslog = 0
log_timestamps = SYSTEM
long_query_time = 3
slow_query_log = 1

general_log_file = general_query_all.log
log_error = error.log
slow_query_log_file = slow_query.log

log_bin_trust_function_creators = 1

[mysql]
show-warnings

prompt = "\u@\h [\d] > "

SQL Script

Si vous copiez le script SQL dans /docker-entrypoint-initdb.d dans le conteneur, il sera exécuté lors de l'initialisation de la base de données.

1_schema.sql

CREATE DATABASE sample_db DEFAULT CHARACTER SET = utf8mb4;

CREATE USER 'test_user'@'%' IDENTIFIED BY 'test_user' PASSWORD EXPIRE NEVER;

GRANT ALL ON sample_db.* TO 'test_user'@'%';

USE sample_db;

CREATE TABLE IF NOT EXISTS memo (
   id BIGINT AUTO_INCREMENT,
   title VARCHAR(255) NOT NULL,
   description TEXT NOT NULL,
   done BOOLEAN DEFAULT FALSE NOT NULL,
   updated TIMESTAMP(3) DEFAULT CURRENT_TIMESTAMP(3) NOT NULL,
   PRIMARY KEY (id)
)
CHARACTER SET = utf8mb4,
COLLATE utf8mb4_general_ci;

2_init_memo_data.sql

USE sample_db;

START TRANSACTION;

INSERT INTO memo (title, description, done, updated) VALUES ('title A', 'description A', false, '2018-08-01');
INSERT INTO memo (title, description, done, updated) VALUES ('title B', 'description B', false, '2018-08-02');

COMMIT;

Conteneur de serveur Redis

L'image utilise le fonctionnaire de Redis.

library/redis - Docker Hub

À propos, lors de l'exécution du serveur Redis sous Windows, le fichier de construction était disponible à partir de Microsoft Archive / redis jusqu'à Redis 3.0, mais les versions 4.0 et supérieures sont fournies. Puisqu'il n'y a rien de tel, vous utiliserez en fait un environnement virtuel tel que Docker.

Dockerfile

FROM redis:4.0.11

COPY ./conf/redis.conf /usr/local/etc/redis/redis.conf

RUN set -x && \
    touch /var/log/redis.log && \
    chown redis:root /var/log/redis.log && \
    chmod 664 /var/log/redis.log

CMD [ "redis-server", "/usr/local/etc/redis/redis.conf" ]

Configuration

/conf/redis.conf est https://raw.githubusercontent.com/antirez/redis/4.0/redis.conf Les parties suivantes ont été modifiées en fonction de. Copiez ce fichier dans /usr/local/etc/redis/redis.conf dans le conteneur et donnez-le comme argument lors du démarrage de redis-server.

** Avant changement **

bind 127.0.0.1
logfile ""
# maxclients 10000
# requirepass foobared
appendonly no

** Changements **

# bind 127.0.0.1
logfile /var/log/redis.log
maxclients 100
requirepass foobared
appendonly yes

logfile

Dans cet exemple, le journal est modifié pour être sorti dans /var/log/redis.log dans le conteneur, mais si le paramètre de fichier journal est défini sur la valeur par défaut, il sera sorti vers la sortie standard (stdout). Vous pouvez vérifier la sortie des journaux vers la sortie standard avec les journaux docker-compose.

> docker-compose logs -f redis-server

Si vous souhaitez surveiller les commandes redis-cli

Utilisez le moniteur redis-cli si vous souhaitez surveiller les commandes exécutées par d'autres clients.

> docker-compose exec redis-server redis-cli
127.0.0.1:6379> auth foobared
OK
127.0.0.1:6379> monitor
OK

requirepass

Si vous commentez bind, vous devrez vous authentifier avec auth avant d'exécuter la commande redis. Définissez le mot de passe spécifié par auth à ce moment avec requirepass.

Conteneur du serveur d'applications

Le serveur d'applications exécute l'application Web développée avec Spring Boot. L'image utilisée n'est pas l'image officielle d'OpenJDK mais l'image officielle de CentOS7, et j'ai installé OpenJDK 1.8 avec yum.

library/centos - Docker Hub

Dockerfile

Je change les paramètres régionaux et j'ajoute un utilisateur appelé app comme utilisateur d'exécution de l'application Web.

FROM centos:7

RUN set -x && \
    yum update -y && \
    yum install -y java-1.8.0-openjdk java-1.8.0-openjdk-devel && \
    yum reinstall -y glibc-common && \
    yum -y clean all

ENV JAVA_HOME /usr/lib/jvm/java-1.8.0-openjdk

# locale settings
ENV LANG ja_JP.UTF-8
ENV LANGUAGE ja_JP:ja

RUN set -x && \
    localedef -i ja_JP -c -f UTF-8 ja_JP.UTF-8 && \
    unlink /etc/localtime && \
    ln -s /usr/share/zoneinfo/Japan /etc/localtime

# application user settings
ENV HOME /home/app

RUN set -x && \
    groupadd app && \
    useradd -g app -d /home/app -s /bin/bash app

WORKDIR $HOME
USER app

COPY start.sh .

EXPOSE 9000

start.sh

Un shell pour exécuter facilement des applications Web. Le conteneur / var / target est le répertoire sur lequel vous avez monté / project-root / demo-redis-spring / target sous Windows. Ce montage est écrit dans docker-compose.yml.

#!/bin/bash

set -x

java -Xmx512m -Xms512m -XX:MaxMetaspaceSize=256m -verbose:gc -Xloggc:app-gc.log -jar /var/target/demo.jar

exécuter l'application Web au démarrage du conteneur du serveur d'applications

Dans cet article, le moment du démarrage du conteneur du serveur d'application et de l'exécution de l'application Web s'exécutant dans ce conteneur sont séparés, mais pour exécuter l'application Web avec le début du conteneur du serveur d'application, la ligne suivante à la fin du Dockerfile Ajouter.

CMD [ "./start.sh" ]

Vous pouvez vérifier les journaux des applications Web avec la commande docker-compose logs.

> docker-compose logs -f --tail=all app-server
Attaching to app-server
app-server      | + java -Xmx512m -Xms512m -XX:MaxMetaspaceSize=256m -verbose:gc -Xloggc:app-gc.log -jar /var/target/demo.jar
app-server      |
app-server      |   .   ____          _            __ _ _
app-server      |  /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
app-server      | ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
app-server      |  \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
app-server      |   '  |____| .__|_| |_|_| |_\__, | / / / /
app-server      |  =========|_|==============|___/=/_/_/_/
app-server      |  :: Spring Boot ::        (v2.0.4.RELEASE)

// ...réduction...

docker-compose.yml

version: "3.6"
services:

  mysql-server:
    container_name: mysql-server
    build:
      context: ./mysql-server
    volumes:
      - mysql-data:/var/lib/mysql
    environment:
      TZ: Asia/Tokyo
      MYSQL_ROOT_PASSWORD: password
    ports:
      - 3306:3306
    networks:
      - redis-network
    restart: always
    tty: true

  redis-server:
    container_name: redis-server
    build:
      context: ./redis-server
    environment:
      TZ: Asia/Tokyo
    volumes:
      - redis-data:/data
    ports:
      - 6379:6379
    networks:
      - redis-network
    restart: always
    tty: true

  app-server:
    build:
      context: ./app-server
    environment:
      TZ: Asia/Tokyo
      SPRING_PROFILES_ACTIVE: docker
    volumes:
      - ./demo-redis-spring/target:/var/target
    depends_on:
      - mysql-server
      - redis-server
    ports:
      - 9000:9000
    networks:
      - redis-network
    restart: always
    stdin_open: true
    tty: true

networks:
  redis-network:
    driver: bridge

volumes:
  mysql-data:
    driver: local
  redis-data:
    driver: local

À propos de Spring Profile

Lors de l'exécution d'une application Spring Boot à partir du conteneur du serveur d'applications, définissez une variable d'environnement appelée SPRING_PROFILES_ACTIVE pour spécifier un profil appelé docker.

app-server:
  environment:
    SPRING_PROFILES_ACTIVE: docker

Bascule la destination de connexion du serveur MySQL et du serveur Redis dans le conteneur avec le profil spécifié. Ce qui suit est un extrait de la partie pertinente du fichier de configuration Spring Boot. Dans le profil appelé docker, les noms d'hôte du serveur MySQL et du serveur Redis sont utilisés comme noms d'hôte des conteneurs.

`application.yml`


spring:
  profiles:
    active: dev

  datasource:
    url: jdbc:mysql://localhost:3306/sample_db?useSSL=false&allowPublicKeyRetrieval=true
    username: test_user
    password: test_user

  redis:
    host: localhost
    port: 6379
    ssl: false
    database: 0
    password: foobared

server:
  port: 9001

---

spring:
  profiles: docker
  datasource:
    url: jdbc:mysql://mysql-server:3306/sample_db?useSSL=false&allowPublicKeyRetrieval=true
  redis:
    host: redis-server

server:
  port: 9000

À propos des ports

Les ports du conteneur mysql-server et redis-server sont exposés à l'extérieur comme indiqué ci-dessous afin que le serveur Mysql du conteneur et le serveur Redis soient accessibles lors de l'exécution d'une application Web sous Windows. ..

mysql-server

ports:
  - 3306:3306

redis-server

ports:
  - 6379:6379

Construire et démarrer / arrêter le conteneur

** Construire **

> docker-compose build

Lorsque vous n'utilisez pas le cache

> docker-compose build --no-cache

Commencez

Le volume est créé au premier démarrage.

> docker-compose up -d
Creating network "docker-demo-redis_redis-network" with driver "bridge"
Creating volume "docker-demo-redis_mysql-data" with local driver
Creating volume "docker-demo-redis_redis-data" with local driver
Creating mysql-server ... done
Creating redis-server ... done
Creating app-server   ... done

À partir de la prochaine fois, la création de volume sera ignorée.

> docker-compose up -d
Creating network "docker-demo-redis_redis-network" with driver "bridge"
Creating mysql-server ... done
Creating redis-server ... done
Creating app-server   ... done

** Redémarrer **

> docker-compose restart
Restarting app-server   ... done
Restarting redis-server ... done
Restarting mysql-server ... done

Arrêtez

> docker-compose down
Stopping app-server   ... done
Stopping mysql-server ... done
Stopping redis-server ... done
Removing app-server   ... done
Removing mysql-server ... done
Removing redis-server ... done
Removing network docker-demo-redis_redis-network

Monter le répertoire cible

Afin d'exécuter l'application Web développée par Spring Boot sur le conteneur du serveur d'application, montez le répertoire cible dans lequel le fichier jar généré est sorti vers / var / target du conteneur du serveur d'application.

  app-server:
    volumes:
      - ./demo-redis-spring/target:/var/target

Exécutez l'application Web

Pour exécuter une application Web, entrez le conteneur du serveur d'application avec la commande exec et exécutez start.sh copié dans le conteneur.

> docker-compose exec app-server bash --login
[app@72e38b38c6ca ~]$ ./start.sh
+ java -Xmx512m -Xms512m -XX:MaxMetaspaceSize=256m -verbose:gc -Xloggc:app-gc.log -jar /var/target/demo.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.4.RELEASE)

2018-08-08 22:09:10.248  INFO 46 --- [           main] com.example.demo.Application             : Starting Application v0.0.1-SNAPSHOT on 72e38b38c6ca with PID 46 (/var/target/demo.jar started by app in /home/app)
2018-08-08 22:09:10.253 DEBUG 46 --- [           main] com.example.demo.Application             : Running with Spring Boot v2.0.4.RELEASE, Spring v5.0.8.RELEASE
2018-08-08 22:09:10.256  INFO 46 --- [           main] com.example.demo.Application             : The following profiles are active: docker

// ...Omis ci-dessous...

Le port 9000 du conteneur du serveur d'application étant exposé à l'extérieur, accédez à http: // localhost: 9000 / à partir du navigateur et confirmez que la page est affichée.

MySQL, persistance des données Redis

Utilisez le volume nommé.

volumes:
  mysql-data:
    driver: local
  redis-data:
    driver: local

Si vous souhaitez initialiser les données, supprimez-les avec la commande docker volume.

** Vérifier le volume **

> docker volume ls
DRIVER              VOLUME NAME
local               docker-demo-redis_mysql-data
local               docker-demo-redis_redis-data

** Supprimer le volume **

> docker volume rm docker-demo-redis_redis-data
docker-demo-redis_redis-data

Si vous le supprimez, il sera créé automatiquement au prochain démarrage.

> docker-compose up -d
Creating network "docker-demo-redis_redis-network" with driver "bridge"
Creating volume "docker-demo-redis_redis-data" with local driver
Creating mysql-server ... done
Creating redis-server ... done
Creating app-server   ... done

Connectez-vous au serveur MySQL à partir de mysql cli

Si vous voulez vous connecter au serveur MySQL et travailler, connectez-vous avec la commande mysql depuis le conteneur mysql-server.

> docker-compose exec mysql-server mysql -u test_user -p --database=sample_db
Enter password:
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 8
Server version: 8.0.12 MySQL Community Server - GPL

Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

test_user@localhost [sample_db] >

Connectez-vous au serveur Redis à partir de redis-cli

Si vous souhaitez vous connecter au serveur Redis et travailler, connectez-vous avec la commande redis-cli du conteneur redis-server.

> docker-compose exec redis-server redis-cli
127.0.0.1:6379> auth foobared
OK
127.0.0.1:6379> keys *
(empty list or set)

Extension du serveur d'applications

Il s'agit d'une méthode pour démarrer n'importe quel nombre de serveurs d'applications comme spécifié.

Correction de docker-compose.yml

Réglez les ports sur le côté qui expose les ports vers l'extérieur comme indiqué ci-dessous. Dans cet exemple, nous voulons que le nombre maximum de montée en charge soit égal à 2, nous avons donc spécifié une plage de ports de 9000,9001.

  app-server:
    ports:
#      - 9000:9000
      - 9000-9001:9000

Commencez

Lorsqu'il est actif, utilisez --scale app-server = num pour spécifier le nombre de serveurs d'applications à démarrer dans num.

> docker-compose up -d --scale app-server=2
Creating network "docker-demo-redis_redis-network" with driver "bridge"
Creating mysql-server ... done
Creating redis-server ... done
WARNING: The "app-server" service specifies a port on the host. If multiple containers for this service are created on a single host, the port will clash.
Creating docker-demo-redis_app-server_1 ... done
Creating docker-demo-redis_app-server_2 ... done

Pour exécuter une commande arbitraire dans le conteneur du serveur d'application, utilisez --index = num et spécifiez dans quel conteneur exécuter avec num.

> docker-compose exec --index=1 app-server bash --login

Vérifiez le nombre de connexions au serveur MySQL

L'application Java de cet article est conçue pour établir deux connexions à partir d'une instance en même temps. À partir des résultats de la liste des processus d'affichage ci-dessous, vous pouvez voir que les Id # 8 et # 9 sont connectés à partir de 172.22.0.4 et les Id # 10 et # 11 sont connectés à partir de 172.22.0.5.

> show processlist;
+----+-----------------+------------------+-----------+---------+------+------------------------+------------------+
| Id | User            | Host             | db        | Command | Time | State                  | Info             |
+----+-----------------+------------------+-----------+---------+------+------------------------+------------------+
|  4 | event_scheduler | localhost        | NULL      | Daemon  |  843 | Waiting on empty queue | NULL             |
|  8 | test_user       | 172.22.0.4:48354 | sample_db | Sleep   |  674 |                        | NULL             |
|  9 | test_user       | 172.22.0.4:48356 | sample_db | Sleep   |  676 |                        | NULL             |
| 10 | test_user       | 172.22.0.5:40842 | sample_db | Sleep   |  263 |                        | NULL             |
| 11 | test_user       | 172.22.0.5:40844 | sample_db | Sleep   |  265 |                        | NULL             |
| 13 | root            | localhost        | NULL      | Query   |    0 | starting               | show processlist |
+----+-----------------+------------------+-----------+---------+------+------------------------+------------------+
6 rows in set (0.00 sec)

Vérifiez le nombre de connexions au serveur Redis

Vous pouvez voir que l'ID client n ° 3 est connecté à partir de 172.22.0.4 et que l'ID n ° 4 est connecté à partir de 172.22.0.5.

127.0.0.1:6379> client list
id=3 addr=172.22.0.4:37174 fd=9 name= age=1621 idle=1621 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=get
id=4 addr=172.22.0.5:44918 fd=10 name= age=1051 idle=1051 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=get
id=5 addr=127.0.0.1:41110 fd=11 name= age=79 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=client

docker-compose scale

docker-compose scale est obsolète. Utilisez plutôt l'indicateur --scale avec la commande up.

This command is deprecated. Use the up command with the --scale flag instead. Beware that using up with --scale flag has some subtle differences with the scale command as it incorporates the behaviour of up command.

Augmenter ou diminuer le nombre de conteneurs à exécuter

Exécutez d'abord un seul serveur d'application.

> docker-compose up -d
Creating network "docker-demo-redis_redis-network" with driver "bridge"
Creating mysql-server ... done
Creating redis-server ... done
Creating docker-demo-redis_app-server_1 ... done

Mettre à l'échelle les conteneurs au nombre spécifié

> docker-compose up -d --scale app-server=2
redis-server is up-to-date
mysql-server is up-to-date
WARNING: The "app-server" service specifies a port on the host. If multiple containers for this service are created on a single host, the port will clash.
Starting docker-demo-redis_app-server_1 ... done
Creating docker-demo-redis_app-server_2 ... done

Réduire les conteneurs au nombre spécifié

> docker-compose up -d --scale app-server=1
redis-server is up-to-date
mysql-server is up-to-date
Stopping and removing docker-demo-redis_app-server_2 ... done
Starting docker-demo-redis_app-server_1              ... done

Créez un environnement de développement d'applications Web qui utilise Java, MySQL et Redis avec Docker CE pour Windows

Aperçu

Créer un environnement d'exécution pour les applications MySQL, Redis et Web

Structure du répertoire du projet

Conteneur pour serveur MySQL

Conteneur de serveur Redis

Si vous souhaitez surveiller les commandes redis-cli

Conteneur du serveur d'applications

exécuter l'application Web au démarrage du conteneur du serveur d'applications

À propos de Spring Profile

application.yml

À propos des ports

Construire et démarrer / arrêter le conteneur

Monter le répertoire cible

Exécutez l'application Web

MySQL, persistance des données Redis

Connectez-vous au serveur MySQL à partir de mysql cli

Connectez-vous au serveur Redis à partir de redis-cli

Extension du serveur d'applications

Correction de docker-compose.yml

Commencez

Vérifiez le nombre de connexions au serveur MySQL

Vérifiez le nombre de connexions au serveur Redis

Augmenter ou diminuer le nombre de conteneurs à exécuter

`application.yml`