Jak mogę zainicjować bazę danych MySQL ze schematem w kontenerze Docker?

Próbuję utworzyć kontener z bazą danych MySQL i dodać schemat do tej bazy danych.

Mój obecny plik Dockerfile to:

FROM mysql
MAINTAINER  (me) <email>

# Copy the database schema to the /data directory
COPY files/epcis_schema.sql /data/epcis_schema.sql

# Change the working directory
WORKDIR data

CMD mysql -u $MYSQL_USER -p $MYSQL_PASSWORD $MYSQL_DATABASE < epcis_schema.sql

W celu stworzenia kontenera kieruję się dokumentacją dostarczoną na Dockerze i wykonuję to polecenie:

docker run --name ${CONTAINER_NAME} -e MYSQL_ROOT_PASSWORD=${DB_ROOT_PASSWORD} -e MYSQL_USER=${DB_USER} -e MYSQL_PASSWORD=${DB_USER_PASSWORD} -e MYSQL_DATABASE=${DB_NAME} -d mvpgomes/epcisdb

Ale kiedy wykonuję to polecenie, kontener nie jest tworzony, aw statusie kontenera można zobaczyć, że CMD nie został wykonany pomyślnie, w rzeczywistości mysqlwykonywane jest tylko polecenie.

W każdym razie, czy istnieje sposób na zainicjowanie bazy danych za pomocą schematu, czy też muszę ręcznie wykonać te operacje?

Przepraszam za tę super długą odpowiedź, ale masz mały sposób, aby dotrzeć tam, gdzie chcesz. Powiem, że normalnie nie umieszczałbyś magazynu dla bazy danych w tym samym kontenerze co sama baza danych, albo montujesz wolumin hosta, aby dane pozostały na hoście dockera, albo być może kontener mógłby zostać użyty do przechowuj dane (/ var / lib / mysql). Poza tym jestem nowy w mysql, więc może to nie być super wydajne. To mówi...

Myślę, że może być kilka problemów. Plik Dockerfile służy do tworzenia obrazu. Musisz wykonać krok kompilacji. Jako minimum z katalogu zawierającego plik Dockerfile możesz zrobić coś takiego:

docker build .

Plik Dockerfile opisuje obraz do utworzenia. Nie wiem zbyt wiele o mysql (jestem fanboyem postgres), ale przeszukałem interwebów pod kątem „jak zainicjować kontener docker mysql”. Najpierw utworzyłem nowy katalog do pracy, nazwałem go mdir, a następnie utworzyłem katalog plików, w którym zdeponowałem plik epcis_schema.sql, który tworzy bazę danych i pojedynczą tabelę:

create database test;
use test;

CREATE TABLE testtab
(
id INTEGER AUTO_INCREMENT,
name TEXT,
PRIMARY KEY (id)
) COMMENT='this is my test table';

Następnie utworzyłem skrypt o nazwie init_db w katalogu plików:

#!/bin/bash

# Initialize MySQL database.
# ADD this file into the container via Dockerfile.
# Assuming you specify a VOLUME ["/var/lib/mysql"] or `-v /var/lib/mysql` on the `docker run` command…
# Once built, do e.g. `docker run your_image /path/to/docker-mysql-initialize.sh`
# Again, make sure MySQL is persisting data outside the container for this to have any effect.

set -e
set -x

mysql_install_db

# Start the MySQL daemon in the background.
/usr/sbin/mysqld &
mysql_pid=$!

until mysqladmin ping >/dev/null 2>&1; do
  echo -n "."; sleep 0.2
done

# Permit root login without password from outside container.
mysql -e "GRANT ALL ON *.* TO root@'%' IDENTIFIED BY '' WITH GRANT OPTION"

# create the default database from the ADDed file.
mysql < /tmp/epcis_schema.sql

# Tell the MySQL daemon to shutdown.
mysqladmin shutdown

# Wait for the MySQL daemon to exit.
wait $mysql_pid

# create a tar file with the database as it currently exists
tar czvf default_mysql.tar.gz /var/lib/mysql

# the tarfile contains the initialized state of the database.
# when the container is started, if the database is empty (/var/lib/mysql)
# then it is unpacked from default_mysql.tar.gz from
# the ENTRYPOINT /tmp/run_db script

(większość tego skryptu została pobrana stąd: https://gist.github.com/pda/9697520 )

Oto utworzone przeze mnie pliki / skrypt run_db:

# start db

set -e
set -x

# first, if the /var/lib/mysql directory is empty, unpack it from our predefined db
[ "$(ls -A /var/lib/mysql)" ] && echo "Running with existing database in /var/lib/mysql" || ( echo 'Populate initial db'; tar xpzvf default_mysql.tar.gz )

/usr/sbin/mysqld

Na koniec plik Dockerfile, aby powiązać je wszystkie:

FROM mysql
MAINTAINER  (me) <email>

# Copy the database schema to the /data directory
ADD files/run_db files/init_db files/epcis_schema.sql /tmp/

# init_db will create the default
# database from epcis_schema.sql, then
# stop mysqld, and finally copy the /var/lib/mysql directory
# to default_mysql_db.tar.gz
RUN /tmp/init_db

# run_db starts mysqld, but first it checks
# to see if the /var/lib/mysql directory is empty, if
# it is it is seeded with default_mysql_db.tar.gz before
# the mysql is fired up

ENTRYPOINT "/tmp/run_db"

Tak więc przeszedłem do mojego katalogu mdir (który zawiera plik Dockerfile wraz z katalogiem plików). Następnie wykonuję polecenie:

docker build --no-cache .

Powinieneś zobaczyć takie dane wyjściowe:

Sending build context to Docker daemon 7.168 kB
Sending build context to Docker daemon 
Step 0 : FROM mysql
 ---> 461d07d927e6
Step 1 : MAINTAINER (me) <email>
 ---> Running in 963e8de55299
 ---> 2fd67c825c34
Removing intermediate container 963e8de55299
Step 2 : ADD files/run_db files/init_db files/epcis_schema.sql /tmp/
 ---> 81871189374b
Removing intermediate container 3221afd8695a
Step 3 : RUN /tmp/init_db
 ---> Running in 8dbdf74b2a79
+ mysql_install_db
2015-03-19 16:40:39 12 [Note] InnoDB: Using atomics to ref count buffer pool pages
...
/var/lib/mysql/ib_logfile0
 ---> 885ec2f1a7d5
Removing intermediate container 8dbdf74b2a79
Step 4 : ENTRYPOINT "/tmp/run_db"
 ---> Running in 717ed52ba665
 ---> 7f6d5215fe8d
Removing intermediate container 717ed52ba665
Successfully built 7f6d5215fe8d

Masz teraz obraz „7f6d5215fe8d”. Mogę uruchomić ten obraz:

docker run -d 7f6d5215fe8d

i obraz się uruchamia, widzę ciąg instancji:

4b377ac7397ff5880bc9218abe6d7eadd49505d50efb5063d6fab796ee157bd3

Mógłbym wtedy go „zatrzymać” i uruchomić ponownie.

docker stop 4b377
docker start 4b377

Jeśli spojrzysz na logi, pierwsza linia będzie zawierać:

docker logs 4b377

Populate initial db
var/lib/mysql/
...

Następnie na końcu dzienników:

Running with existing database in /var/lib/mysql

Są to komunikaty ze skryptu / tmp / run_db, pierwsza wskazuje, że baza danych została rozpakowana z zapisanej (początkowej) wersji, druga wskazuje, że baza już tam była, więc została wykorzystana istniejąca kopia.

Oto ls -lR struktury katalogów, którą opisałem powyżej. Zauważ, że init_db i run_db to skrypty z ustawionym bitem wykonania:

gregs-air:~ gfausak$ ls -Rl mdir
total 8
-rw-r--r--  1 gfausak  wheel  534 Mar 19 11:13 Dockerfile
drwxr-xr-x  5 gfausak  staff  170 Mar 19 11:24 files

mdir/files:
total 24
-rw-r--r--  1 gfausak  staff   126 Mar 19 11:14 epcis_schema.sql
-rwxr-xr-x  1 gfausak  staff  1226 Mar 19 11:16 init_db
-rwxr-xr-x  1 gfausak  staff   284 Mar 19 11:23 run_db

Miałem ten sam problem, w którym chciałem zainicjować schemat mojej instancji MySQL Docker, ale napotkałem trudności z jego działaniem po wykonaniu niektórych Googling i podążaniu za przykładami innych. Oto jak to rozwiązałem.

1) Zrzuć schemat MySQL do pliku.

mysqldump -h <your_mysql_host> -u <user_name> -p --no-data <schema_name> > schema.sql

2) Użyj polecenia ADD, aby dodać plik schematu do /docker-entrypoint-initdb.dkatalogu w kontenerze Docker. docker-entrypoint.shPlik będzie uruchamiać żadnych plików w tym katalogu kończącego się ".sql"z bazą danych MySQL.

Dockerfile:

FROM mysql:5.7.15

MAINTAINER me

ENV MYSQL_DATABASE=<schema_name> \
    MYSQL_ROOT_PASSWORD=<password>

ADD schema.sql /docker-entrypoint-initdb.d

EXPOSE 3306

3) Uruchom instancję Docker MySQL.

docker-compose build
docker-compose up

Dzięki skonfigurowaniu MySQL i zaimportowaniu zrzutu w ramach pliku Dockerfile za podpowiedź do pliku docker-entrypoint.sh oraz fakt, że uruchamia on zarówno skrypty SQL, jak i skrypty powłoki!

Inny sposób oparty na połączeniu wcześniejszych odpowiedzi serwera:

plik docker-compose:

version: "3"
services:
    db:
      container_name: db
      image: mysql
      ports:
       - "3306:3306"  
      environment:
         - MYSQL_ROOT_PASSWORD=mysql
         - MYSQL_DATABASE=db

      volumes:
         - /home/user/db/mysql/data:/var/lib/mysql
         - /home/user/db/mysql/init:/docker-entrypoint-initdb.d/:ro

gdzie /home/user.. to folder współdzielony na hoście

A w /home/user/db/mysql/initfolderze ... po prostu upuść jeden plik sql o dowolnej nazwie, na przykład init.sqlzawierający:

CREATE DATABASE mydb;
GRANT ALL PRIVILEGES ON mydb.* TO 'myuser'@'%' IDENTIFIED BY 'mysql';
GRANT ALL PRIVILEGES ON mydb.* TO 'myuser'@'localhost' IDENTIFIED BY 'mysql';
USE mydb
CREATE TABLE CONTACTS (
    [ ... ]
);
INSERT INTO CONTACTS VALUES ...
[ ... ]

Zgodnie z oficjalną dokumentacją mysql możesz umieścić w nim więcej niż jeden plik sql docker-entrypoint-initdb.d, są one wykonywane w kolejności alfabetycznej

Innym prostym sposobem jest użycie docker-compose z następującymi wierszami:

mysql:
  from: mysql:5.7
  volumes:
    - ./database:/tmp/database
  command: mysqld --init-file="/tmp/database/install_db.sql"

Umieść schemat bazy danych w pliku ./database/install_db.sql. Za każdym razem, gdy budujesz kontener, zostanie wykonany plik install_db.sql.

Wypróbowałem odpowiedź Grega bez powodzenia, musiałem zrobić coś złego, ponieważ moja baza danych nie zawierała danych po wszystkich krokach: na wszelki wypadek korzystałem z najnowszego obrazu MariaDB.

Następnie zdecydowałem się przeczytać punkt wejścia dla oficjalnego obrazu MariaDB i użyłem go do wygenerowania prostego pliku docker-compose :

database:
  image: mariadb
  ports:
     - 3306:3306
  expose:
     - 3306
  volumes:
     - ./docker/mariadb/data:/var/lib/mysql:rw
     - ./database/schema.sql:/docker-entrypoint-initdb.d/schema.sql:ro
  environment:
     MYSQL_ALLOW_EMPTY_PASSWORD: "yes"

Teraz mogę utrwalać moje dane ORAZ generować bazę danych z własnym schematem!

Po 4 sierpnia 2015 r., Jeśli korzystasz z oficjalnego obrazu mysql Docker, możesz po prostu DODAĆ / SKOPIOWAĆ plik do katalogu /docker-entrypoint-initdb.d/ i będzie on działał po zainicjowaniu kontenera. Zobacz github: https://github.com/docker-library/mysql/commit/14f165596ea8808dfeb2131f092aabe61c967225, jeśli chcesz go zaimplementować na innych obrazach kontenerów

Najłatwiejszym rozwiązaniem jest użycie tutum / mysql

Krok 1

docker pull tutum/mysql:5.5

Krok 2

docker run -d -p 3306:3306 -v /tmp:/tmp  -e STARTUP_SQL="/tmp/to_be_imported.mysql" tutum/mysql:5.5

Krok 3

Wejdź powyżej CONTAINER_ID, a następnie wykonaj polecenie, docker logsaby zobaczyć wygenerowane informacje o haśle.

docker logs #<CONTAINER_ID>

Dla tych, którzy nie chcą tworzyć skryptu punktu wejścia, takiego jak ja, możesz uruchomić mysqld w czasie kompilacji, a następnie wykonać polecenia mysql w pliku Dockerfile w następujący sposób:

RUN mysqld_safe & until mysqladmin ping; do sleep 1; done && \
    mysql -uroot -e "CREATE DATABASE somedb;" && \
    mysql -uroot -e "CREATE USER 'someuser'@'localhost' IDENTIFIED BY 'somepassword';" && \
    mysql -uroot -e "GRANT ALL PRIVILEGES ON somedb.* TO 'someuser'@'localhost';"

Kluczem jest tutaj wysłanie mysqld_safe do tła z pojedynczym &znakiem.

Poniżej znajduje się plik Dockerfile, którego z powodzeniem użyłem do zainstalowania xampp, utworzenia MariaDB ze schematem i wstępnie wypełnionego informacjami używanymi na serwerze lokalnym (usrs, zamówienia zdjęć itp.)

FROM ubuntu:14.04

COPY Ecommerce.sql /root

RUN apt-get update \
 && apt-get install wget -yq \
 && apt-get install nano \
 && wget https://www.apachefriends.org/xampp-files/7.1.11/xampp-linux-x64-7.1.11-0-installer.run \
 && mv xampp-linux-x64-7.1.11-0-installer.run /opt/ \
 && cd /opt/ \
 && chmod +x xampp-linux-x64-7.1.11-0-installer.run \
 && printf 'y\n\y\n\r\n\y\n\r\n' | ./xampp-linux-x64-7.1.11-0-installer.run \
 && cd /opt/lampp/bin \
 && /opt/lampp/lampp start \
 && sleep 5s \

 && ./mysql -uroot -e "CREATE DATABASE Ecommerce" \
 && ./mysql -uroot -D Ecommerce < /root/Ecommerce.sql \
 && cd / \
 && /opt/lampp/lampp reload \
 && mkdir opt/lampp/htdocs/Ecommerce

COPY /Ecommerce /opt/lampp/htdocs/Ecommerce

EXPOSE 80

Po trochę zmaganiach z tym, spójrz na plik Dockerfile przy użyciu nazwanych woluminów (db-data). Ważne jest zadeklarowanie plusa w końcowej części, gdzie wspomniałem, że wolumen jest[external]

W ten sposób wszystko działało świetnie!

version: "3"

services:

  database:
    image: mysql:5.7
    container_name: mysql
    ports:
      - "3306:3306"
    volumes:
      - db-data:/docker-entrypoint-initdb.d
    environment:
      - MYSQL_DATABASE=sample
      - MYSQL_ROOT_PASSWORD=root

volumes:
  db-data:
    external: true