Comment puis-je savoir quand mon menu fixe mysql conteneur est en place et mysql est prêt à prendre des requêtes?

Vous pouvez installer mysql-client package et utiliser la commande mysqladmin de ping serveur cible. Utile lorsque vous travaillez avec plusieurs conteneur docker. Combiner avec le sommeil, et de créer une simple attente de la boucle:

while ! mysqladmin ping -h"$DB_HOST" --silent; do
    sleep 1
done

Cela a été plus ou moins mentionné dans les commentaires pour les autres réponses, mais je pense qu'il mérite sa propre entrée.

Tout d'abord, vous pouvez exécuter votre conteneur de la manière suivante:

docker run --name mysql --health-cmd='mysqladmin ping --silent' -d mysql

Il y a aussi un équivalent dans le Dockerfile.

De la commande de votre docker ps et docker inspect va vous montrer l'état de santé de votre conteneur. Pour mysql, en particulier, cette méthode a l'avantage de mysqladmin être disponible à l'intérieur du conteneur, de sorte que vous n'avez pas besoin de l'installer sur le panneau d'accueil.

Alors vous pouvez simplement boucle dans un script bash pour attendre sur le statut de devenir sain. Le script bash suivant est créé par Dennis.

function getContainerHealth {
  docker inspect --format "{{json .State.Health.Status }}" $1
}

function waitContainer {
  while STATUS=$(getContainerHealth $1); [ $STATUS != "\"healthy\"" ]; do 
    if [ $STATUS == "\"unhealthy\"" ]; then
      echo "Failed!"
      exit -1
    fi
    printf .
    lf=$'\n'
    sleep 1
  done
  printf "$lf"
}

Maintenant, vous pouvez le faire dans votre script:

waitContainer mysql

et votre script va attendre jusqu'à ce que le conteneur est en place et en cours d'exécution. Le script va quitter si le conteneur devient malsain, ce qui est possible, si par exemple le panneau d'accueil est de mémoire, de sorte que mysql ne peut pas allouer suffisamment de il pour lui-même.

J'ai trouvé que l'utilisation de la mysqladmin ping approche n'est pas toujours fiable, surtout si vous êtes de mettre en place un nouveau DB. Dans ce cas, même si vous êtes en mesure de faire un ping du serveur, vous pourriez être incapable de se connecter si l'utilisateur/privilège tables sont encore en cours d'initialisation. Au lieu de cela, je fais quelque chose comme ce qui suit:

while ! docker exec db-container mysql --user=foo --password=bar -e "SELECT 1" >/dev/null 2>&1; do
    sleep 1
done

Jusqu'à présent, je n'ai pas rencontré de problèmes avec cette méthode. Je vois que quelque chose de similaire a été proposé par VinGarcia dans un commentaire à l'un des mysqladmin ping réponses.

J'ai eu le même problème lors de mon Django conteneur essayé de vous connecter la base de données mysql contenant juste après qu'il a commencé. Je l'ai résolu en utilisant la vishnubob de wait-for.it.sh script. Ses un script shell qui attend une adresse IP et un hôte pour être prêt avant de continuer. Voici l'exemple que j'utilise pour mon applicaction.

./wait-for-it.sh \
    -h $(docker inspect --format '{{ .NetworkSettings.IPAddress }}' $MYSQL_CONTAINER_NAME) \
    -p 3306 \
    -t 90

Dans le script que je suis en demandant à la base de données mysql contenant attendre un maximum de 90 secondes (il sera exécuté normalement, lorsque vous êtes prêt) dans le port 3306 (par défaut le port mysql) et l'hôte asigned par docker pour mon MYSQL_CONTAINER_NAME. Le script ont plus variables, mais pour mw travaillé avec ces trois.

J'ai développé une nouvelle solution de ce problème basée sur une nouvelle approche. Toutes les approches que j'ai trouvé compter sur un script qui tente de se connecter à la base de données, ou d'essayer d'établir une connexion TCP avec le conteneur. Tous les détails peuvent être trouvés sur le waitdb référentiel, mais, ma solution est de s'appuyer sur l'extrait du journal à partir du conteneur. Le script attend jusqu'à ce que les feux de bois le message prêt pour les connexions. Le script peut identifier si le conteneur de départ pour la première fois. Dans ce cas, le script attend jusqu'à ce que la base de données initiale script est exécuté et la base de données est redémarré, en attente de nouveau pour une nouvelle prêt pour les connexions message. J'ai testé cette solution sur MySQL 5.7 et MySQL 8.0.

Le script lui-même (wait_db.sh):

#!/bin/bash

STRING_CONNECT="mysqld: ready for connections"

findString() {
    ($1 logs -f $4 $5 $6 $7 $8 $9 2>&1 | grep -m $3 "$2" &) | grep -m $3 "$2" > /dev/null
}

echo "Waiting startup..."
findString $1 "$STRING_CONNECT" 1 $2 $3 $4 $5 $6 $7
$1 logs $2 $3 $4 $5 2>&1 | grep -q "Initializing database"
if [ $? -eq 0 ] ; then
    echo "Almost there..."
    findString $1 "$STRING_CONNECT" 2 $2 $3 $4 $5 $6 $7
fi
echo "Server is up!"

Le script peut être utilisé dans le Panneau composition ou dans le Panneau lui-même. J'espère que les exemples soufflet que l'usage clair:

Exemple 01: Utilisation avec menu fixe Composer

SERVICE_NAME="mysql" && \
docker-compose up -d $SERVICE_NAME && \
./wait_db.sh docker-compose --no-color $SERVICE_NAME

Exemple 02: Utilisation avec menu fixe

CONTAINER_NAME="wait-db-test" && \
ISO_NOW=$(date -uIs) && \
  docker run --rm --name $CONTAINER_NAME \
    -e MYSQL_ROOT_PASSWORD=$ROOT_PASSWORD \
    -d mysql:5.7 && \
./wait_db.sh docker --since "$ISO_NOW" $CONTAINER_NAME

Exemple 3: Un exemple complet (le test)

Un exemple complet peut être trouvé sur le cas de test du référentiel. Ce test-cas de démarrage d'une nouvelle MySQL, créer un mannequin de base de données, attendre jusqu'à ce que tout est commencé et puis lance un sélectionnez pour vérifier si tout va bien. Après qu'il va redémarrer le conteneur et d'attendre d'être démarré et puis lance un nouveau sélectionnez pour vérifier si il est prêt pour la connexion.

Sur votre ENTRYPOINT script, vous devez vérifier si vous possédez une carte de connexion MySQL ou pas.

Cette solution ne requiert pas l'installation d'un Client MySQL sur le conteneur et pendant l'exécution du conteneur avec php:7.0-fpm de course nc n'était pas une option, car il a dû être installés. En outre, vérifier si le port est ouvert ne signifie pas nécessairement que le service est en cours d'exécution et correctement exposées. [plus de cela]

Donc, dans cette solution, je vais vous montrer comment exécuter un script PHP pour vérifier si une base de données MySQL Contenant est en mesure de prendre de connexion. Si vous voulez savoir pourquoi je pense que c'est une meilleure approche de vérifier mon commentaire ici.

Fichier entrypoint.sh

#!/bin/bash
cat << EOF > /tmp/wait_for_mysql.php
<?php
$connected = false;
while(!$connected) {
    try{
        $dbh = new pdo( 
            'mysql:host=mysql:3306;dbname=db_name', 'db_user', 'db_pass',
            array(PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION)
        );
        $connected = true;
    }
    catch(PDOException $ex){
        error_log("Could not connect to MySQL");
        error_log($ex->getMessage());
        error_log("Waiting for MySQL Connection.");
        sleep(5);
    }
}
EOF
php /tmp/wait_for_mysql.php
# Rest of entry point bootstrapping

Par l'exécution de cette, vous êtes essentiellement en bloquant toute logique d'amorçage de votre récipient JUSQU'à ce que vous possédez une carte de Connexion MySQL.

J'utilise le code suivant ;

exportation COMPOSE_PROJECT_NAME=web;

exportation IS_DATA_CONTAINER_EXISTS=$(docker volume ls | grep ${COMPOSE_PROJECT_NAME}_sqldata);

docker-compose up -d;
docker-compose ps;

export NETWORK_GATEWAY=$(docker inspect --format='{{range .NetworkSettings.Networks}}{{.Gateway}}{{end}}' ${COMPOSE_PROJECT_NAME}_webserver1_con);