Konfigurowanie MySQL i importowanie zrzutu w Dockerfile

Próbuję skonfigurować plik Dockerfile dla mojego projektu LAMP, ale mam kilka problemów podczas uruchamiania MySQL. Mam następujące wiersze w moim pliku Dockerfile:

VOLUME ["/etc/mysql", "/var/lib/mysql"]
ADD dump.sql /tmp/dump.sql
RUN /usr/bin/mysqld_safe & sleep 5s
RUN mysql -u root -e "CREATE DATABASE mydb"
RUN mysql -u root mydb < /tmp/dump.sql

Ale ciągle otrzymuję ten błąd:

ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (111)

Masz jakieś pomysły, jak skonfigurować tworzenie bazy danych i importować zrzuty podczas kompilacji pliku Dockerfile?

Każda RUNinstrukcja w a Dockerfilejest wykonywana w innej warstwie (jak wyjaśniono w dokumentacjiRUN ).

W swoim Dockerfilemasz trzy RUNinstrukcje. Problem w tym, że serwer MySQL jest uruchamiany dopiero w pierwszej. W innych nie działa MySQL, dlatego pojawia się błąd połączenia z mysqlklientem.

Aby rozwiązać ten problem, masz 2 rozwiązania.

Rozwiązanie 1: użyj jednej linii RUN

RUN /bin/bash -c "/usr/bin/mysqld_safe --skip-grant-tables &" && \
  sleep 5 && \
  mysql -u root -e "CREATE DATABASE mydb" && \
  mysql -u root mydb < /tmp/dump.sql

Rozwiązanie 2: użyj skryptu

Utwórz wykonywalny skrypt init_db.sh:

#!/bin/bash
/usr/bin/mysqld_safe --skip-grant-tables &
sleep 5
mysql -u root -e "CREATE DATABASE mydb"
mysql -u root mydb < /tmp/dump.sql

Dodaj te wiersze do Dockerfile:

ADD init_db.sh /tmp/init_db.sh
RUN /tmp/init_db.sh

Najnowsza wersja oficjalnego obrazu dockera mysql umożliwia importowanie danych podczas uruchamiania. Oto mój plik docker-compose.yml

data:
  build: docker/data/.
mysql:
  image: mysql
  ports:
    - "3307:3306"
  environment:
    MYSQL_ROOT_PASSWORD: 1234
  volumes:
    - ./docker/data:/docker-entrypoint-initdb.d
  volumes_from:
    - data

Tutaj mam docker/dataplik data-dump.sql, pod którym jest względny folder, z którego działa docker-compose. Podłączam ten plik sql do tego katalogu /docker-entrypoint-initdb.dw kontenerze.

Jeśli jesteś zainteresowany, aby zobaczyć, jak to działa, spójrz na ich docker-entrypoint.shw GitHub. Dodali ten blok, aby umożliwić importowanie danych

    echo
    for f in /docker-entrypoint-initdb.d/*; do
        case "$f" in
            *.sh)  echo "$0: running $f"; . "$f" ;;
            *.sql) echo "$0: running $f"; "${mysql[@]}" < "$f" && echo ;;
            *)     echo "$0: ignoring $f" ;;
        esac
        echo
    done

Dodatkowa uwaga, jeśli chcesz, aby dane były utrwalane nawet po zatrzymaniu i usunięciu kontenera mysql, musisz mieć oddzielny kontener danych, jak widać w pliku docker-compose.yml. Zawartość kontenera danych Dockerfile jest bardzo prosta.

FROM n3ziniuka5/ubuntu-oracle-jdk:14.04-JDK8

VOLUME /var/lib/mysql

CMD ["true"]

Aby zachować trwałość, kontener danych nie musi nawet znajdować się w stanie początkowym.

To, co zrobiłem, to pobranie zrzutu sql do folderu „db-dump” i zamontowanie go:

mysql:
 image: mysql:5.6
 environment:
   MYSQL_ROOT_PASSWORD: pass
 ports:
   - 3306:3306
 volumes:
   - ./db-dump:/docker-entrypoint-initdb.d

Kiedy uruchamiam docker-compose uppo raz pierwszy, zrzut jest przywracany w bazie danych.

Użyłem podejścia docker-entrypoint-initdb.d (dzięki @Kuhess) Ale w moim przypadku chcę utworzyć moją bazę danych na podstawie niektórych parametrów, które zdefiniowałem w pliku .env, więc zrobiłem te

1) Najpierw definiuję plik .env coś takiego w moim głównym katalogu projektu docker

MYSQL_DATABASE=my_db_name
MYSQL_USER=user_test
MYSQL_PASSWORD=test
MYSQL_ROOT_PASSWORD=test
MYSQL_PORT=3306

2) Następnie definiuję mój plik docker-compose.yml. Więc użyłem dyrektywy args do zdefiniowania moich zmiennych środowiskowych i ustawiłem je z pliku .env

version: '2'
services:
### MySQL Container
    mysql:
        build:
            context: ./mysql
            args:
                - MYSQL_DATABASE=${MYSQL_DATABASE}
                - MYSQL_USER=${MYSQL_USER}
                - MYSQL_PASSWORD=${MYSQL_PASSWORD}
                - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
        ports:
            - "${MYSQL_PORT}:3306"

3) Następnie definiuję folder mysql zawierający plik Dockerfile. Więc to jest plik Dockerfile

FROM mysql:5.7
RUN chown -R mysql:root /var/lib/mysql/

ARG MYSQL_DATABASE
ARG MYSQL_USER
ARG MYSQL_PASSWORD
ARG MYSQL_ROOT_PASSWORD

ENV MYSQL_DATABASE=$MYSQL_DATABASE
ENV MYSQL_USER=$MYSQL_USER
ENV MYSQL_PASSWORD=$MYSQL_PASSWORD
ENV MYSQL_ROOT_PASSWORD=$MYSQL_ROOT_PASSWORD

ADD data.sql /etc/mysql/data.sql
RUN sed -i 's/MYSQL_DATABASE/'$MYSQL_DATABASE'/g' /etc/mysql/data.sql
RUN cp /etc/mysql/data.sql /docker-entrypoint-initdb.d

EXPOSE 3306

4) Teraz używam mysqldump do zrzucenia mojej bazy danych i umieszczenia data.sql w folderze mysql

mysqldump -h <server name> -u<user> -p <db name> > data.sql

Plik jest zwykłym plikiem zrzutu sql, ale dodaję 2 wiersze na początku, aby plik wyglądał tak

--
-- Create a database using `MYSQL_DATABASE` placeholder
--
CREATE DATABASE IF NOT EXISTS `MYSQL_DATABASE`;
USE `MYSQL_DATABASE`;

-- Rest of queries
DROP TABLE IF EXISTS `x`;
CREATE TABLE `x` (..)
LOCK TABLES `x` WRITE;
INSERT INTO `x` VALUES ...;
...
...
...

Więc co się stało, to że użyłem polecenia "RUN sed -i 's / MYSQL_DATABASE /' $ MYSQL_DATABASE '/ g' /etc/mysql/data.sql", aby zastąpić MYSQL_DATABASEsymbol zastępczy nazwą mojej bazy danych, w której ją ustawiłem plik .env.

|- docker-compose.yml
|- .env
|- mysql
     |- Dockerfile
     |- data.sql

Teraz możesz zbudować i uruchomić swój kontener

Oto działająca wersja korzystająca v3z docker-compose.yml. Kluczem jest dyrektywa o objętości :

mysql:
  image: mysql:5.6
  ports:
    - "3306:3306"
  environment:
    MYSQL_ROOT_PASSWORD: root
    MYSQL_USER: theusername
    MYSQL_PASSWORD: thepw
    MYSQL_DATABASE: mydb
  volumes:
    - ./data:/docker-entrypoint-initdb.d

W katalogu Mam docker-compose.ymlMam datadir, który zawiera .sqlpliki zrzutu. Jest to miłe, ponieważ możesz mieć .sqlplik zrzutu na tabelę.

Po prostu biegnę docker-compose upi jestem gotowy. Dane pozostają automatycznie między przystankami. Jeśli chcesz usunąć dane i „zassać” nowe .sqlpliki, uruchom docker-compose downwtedy docker-compose up.

Jeśli ktoś wie, jak zmusić mysqldockera do ponownego przetwarzania plików /docker-entrypoint-initdb.dbez usuwania woluminu, zostaw komentarz, a zaktualizuję tę odpowiedź.