Configurazione di MySQL e importazione di dump in Dockerfile

Sto cercando di impostare un Dockerfile per il mio progetto LAMP, ma ho alcuni problemi all'avvio di MySQL. Ho le seguenti righe sul mio 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

Ma continuo a ricevere questo errore:

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

Qualche idea su come impostare la creazione del database e l'importazione del dump durante una build Dockerfile?

Ogni RUNistruzione in a Dockerfileviene eseguita in un livello diverso (come spiegato nella documentazione diRUN ).

Nel tuo Dockerfile, hai tre RUNistruzioni. Il problema è che il server MySQL viene avviato solo nel primo. Negli altri, nessun MySQL è in esecuzione, ecco perché ricevi il tuo errore di connessione con il mysqlclient.

Per risolvere questo problema hai 2 soluzioni.

Soluzione 1: usa una riga 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

Soluzione 2: usa uno script

Crea uno script eseguibile 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

Aggiungi queste righe a Dockerfile:

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

L'ultima versione dell'immagine ufficiale mysql docker consente di importare i dati all'avvio. Ecco il mio 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

Qui, ho il mio data-dump.sql sotto il docker/dataquale è relativo alla cartella da cui è in esecuzione docker-compose. Sto montando quel file sql in questa directory /docker-entrypoint-initdb.dsul contenitore.

Se sei interessato a vedere come funziona, dai un'occhiata al loro docker-entrypoint.shsu GitHub. Hanno aggiunto questo blocco per consentire l'importazione dei dati

    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

Una nota aggiuntiva, se vuoi che i dati siano persistenti anche dopo che il contenitore mysql è stato arrestato e rimosso, devi avere un contenitore di dati separato come vedi nel docker-compose.yml. I contenuti del contenitore dati Dockerfile sono molto semplici.

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

VOLUME /var/lib/mysql

CMD ["true"]

Il contenitore di dati non deve nemmeno essere nello stato iniziale per la persistenza.

Quello che ho fatto è stato scaricare il mio dump sql in una cartella "db-dump" e montarlo:

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

Quando eseguo docker-compose upper la prima volta, il dump viene ripristinato nel db.

Ho usato l'approccio docker-entrypoint-initdb.d (Grazie a @Kuhess) Ma nel mio caso voglio creare il mio DB in base ad alcuni parametri che ho definito nel file .env quindi ho fatto questi

1) Per prima cosa definisco il file .env qualcosa di simile nella mia directory del progetto di root docker

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

2) Quindi definisco il mio file docker-compose.yml. Quindi ho usato la direttiva args per definire le mie variabili di ambiente e le ho impostate dal file .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) Quindi definisco una cartella mysql che include un Dockerfile. Quindi il Dockerfile è questo

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) Ora uso mysqldump per scaricare il mio db e inserire data.sql nella cartella mysql

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

Il file è solo un normale file di dump sql ma aggiungo 2 righe all'inizio in modo che il file assomigli a questo

--
-- 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 ...;
...
...
...

Quindi quello che sta succedendo è che ho usato il comando "RUN sed -i 's / MYSQL_DATABASE /' $ MYSQL_DATABASE '/ g' /etc/mysql/data.sql" per sostituire il MYSQL_DATABASEsegnaposto con il nome del mio DB in cui l'ho impostato file .env.

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

Ora sei pronto per creare ed eseguire il tuo container

Ecco una versione funzionante utilizzando v3dei docker-compose.yml. La chiave è la direttiva sui volumi :

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

Nella directory che ho mia docker-compose.ymlho una directory datache contiene i .sqlfile di dump. Questo è utile perché puoi avere un .sqlfile di dump per tabella.

Corro semplicemente docker-compose upe sono a posto. I dati persistono automaticamente tra le fermate. Se si desidera cancellare i dati e "risucchiare" nuovi .sqlfile eseguiti docker-compose downpoi docker-compose up.

Se qualcuno sa come ottenere la mysqlfinestra mobile per rielaborare i file /docker-entrypoint-initdb.dsenza rimuovere il volume, lascia un commento e aggiornerò questa risposta.

Non mi piace molto la risposta accettata da sleep 5Kuhess in quanto mi sembra un po 'hacker poiché presume che il demone mysql db sia stato caricato correttamente entro questo lasso di tempo. È un presupposto, nessuna garanzia. Inoltre, se si utilizza un'immagine docker mysql fornita, l'immagine stessa si occupa già di avviare il server; Non interferirei con questo con un'usanza /usr/bin/mysqld_safe.

Ho seguito le altre risposte qui intorno e ho copiato gli script bash e sql nella cartella /docker-entrypoint-initdb.d/all'interno del contenitore docker poiché questo è chiaramente il modo previsto dal provider di immagini mysql. Tutto in questa cartella viene eseguito una volta che il demone db è pronto, quindi dovresti essere in grado di fare affidamento su di esso.

In aggiunta alle altre, poiché nessun'altra risposta lo menziona esplicitamente: oltre agli script sql puoi anche copiare gli script bash in quella cartella che potrebbe darti un maggiore controllo.

Questo è ciò di cui avevo bisogno, ad esempio, poiché avevo anche bisogno di importare un dump, ma il dump da solo non era sufficiente in quanto non forniva in quale database importare. Quindi nel mio caso ho uno script denominato db_custom_init.shcon questo contenuto:

mysql -u root -p$MYSQL_ROOT_PASSWORD -e 'create database my_database_to_import_into'
mysql -u root -p$MYSQL_ROOT_PASSWORD my_database_to_import_into < /home/db_dump.sql

e questo Dockerfile che copia quello script:

FROM mysql/mysql-server:5.5.62
ENV MYSQL_ROOT_PASSWORD=XXXXX
COPY ./db_dump.sql /home/db_dump.sql
COPY ./db_custom_init.sh /docker-entrypoint-initdb.d/

modifica: nota che questo importerebbe solo il dump sql al momento della creazione del contenitore, non al momento della creazione dell'immagine!