À l'aide de Docker-Compose, comment exécuter plusieurs commandes

Je veux faire quelque chose comme ça où je peux exécuter plusieurs commandes dans l'ordre.

db:
  image: postgres
web:
  build: .
  command: python manage.py migrate
  command: python manage.py runserver 0.0.0.0:8000
  volumes:
    - .:/code
  ports:
    - "8000:8000"
  links:
    - db

Compris, utilisez bash -c.

Exemple:

command: bash -c "python manage.py migrate && python manage.py runserver 0.0.0.0:8000"

Même exemple dans les multilignes:

command: >
    bash -c "python manage.py migrate
    && python manage.py runserver 0.0.0.0:8000"

Ou:

command: bash -c "
    python manage.py migrate
    && python manage.py runserver 0.0.0.0:8000
  "

J'exécute des trucs de pré-démarrage comme des migrations dans un conteneur éphémère séparé, comme ça (notez que le fichier de composition doit être de type '2'):

db:
  image: postgres
web:
  image: app
  command: python manage.py runserver 0.0.0.0:8000
  volumes:
    - .:/code
  ports:
    - "8000:8000"
  links:
    - db
  depends_on:
    - migration
migration:
  build: .
  image: app
  command: python manage.py migrate
  volumes:
    - .:/code
  links:
    - db
  depends_on:
    - db

Cela aide à garder les choses propres et séparées. Deux choses à considérer:

1. Vous devez vous assurer de la séquence de démarrage correcte (en utilisant depend_on)

2. vous voulez éviter plusieurs builds ce qui est réalisé en le marquant la première fois en utilisant build et image; vous pouvez vous référer à l'image dans d'autres conteneurs puis

Je recommande d'utiliser shpar opposition à bashcar il est plus facilement disponible sur la plupart des images basées sur Unix (alpine, etc.).

Voici un exemple docker-compose.yml:

version: '3'

services:
  app:
    build:
      context: .
    command: >
      sh -c "python manage.py wait_for_db &&
             python manage.py migrate &&
             python manage.py runserver 0.0.0.0:8000"

Cela appellera les commandes suivantes dans l'ordre:

• python manage.py wait_for_db - attendez que la base de données soit prête
• python manage.py migrate - exécuter toutes les migrations
• python manage.py runserver 0.0.0.0:8000 - démarrer mon serveur de développement

Cela fonctionne pour moi:

version: '3.1'
services:
  db:
    image: postgres
  web:
    build: .
    command:
      - /bin/bash
      - -c
      - |
        python manage.py migrate
        python manage.py runserver 0.0.0.0:8000

    volumes:
      - .:/code
    ports:
      - "8000:8000"
    links:
      - db

docker-compose essaie de déréférencer les variables avant d' exécuter la commande, donc si vous voulez que bash gère les variables, vous devrez échapper aux signes dollar en les doublant ...

    command:
      - /bin/bash
      - -c
      - |
        var=$$(echo 'foo')
        echo $$var # prints foo

... sinon vous obtiendrez une erreur:

Format d'interpolation non valide pour l'option "commande" dans le service "web":

Vous pouvez utiliser le point d'entrée ici. Le point d'entrée dans Docker est exécuté avant la commande tandis que la commande est la commande par défaut qui doit être exécutée au démarrage du conteneur. Ainsi, la plupart des applications comportent généralement une procédure de configuration dans un fichier de point d'entrée et, dans le dernier, elles permettent l'exécution de la commande.

faire un fichier de script shell peut être comme docker-entrypoint.sh(le nom n'a pas d'importance) avec le contenu suivant.

#!/bin/bash
python manage.py migrate
exec "$@"

dans le fichier docker-compose.yml, utilisez-le avec entrypoint: /docker-entrypoint.shet enregistrez la commande en tant que command: python manage.py runserver 0.0.0.0:8000 PS: n'oubliez pas de copier docker-entrypoint.shavec votre code.

Une autre idée:

Si, comme dans ce cas, vous créez le conteneur, placez-y simplement un script de démarrage et exécutez-le avec la commande. Ou montez le script de démarrage en tant que volume.

* MISE À JOUR *

J'ai pensé que la meilleure façon d'exécuter certaines commandes est d'écrire un Dockerfile personnalisé qui fait tout ce que je veux avant que le CMD officiel ne soit exécuté à partir de l'image.

docker-compose.yaml:

version: '3'

# Can be used as an alternative to VBox/Vagrant
services:

  mongo:
    container_name: mongo
    image: mongo
    build:
      context: .
      dockerfile: deploy/local/Dockerfile.mongo
    ports:
      - "27017:27017"
    volumes:
      - ../.data/mongodb:/data/db

Dockerfile.mongo:

FROM mongo:3.2.12

RUN mkdir -p /fixtures

COPY ./fixtures /fixtures

RUN (mongod --fork --syslog && \
     mongoimport --db wcm-local --collection clients --file /fixtures/clients.json && \
     mongoimport --db wcm-local --collection configs --file /fixtures/configs.json && \
     mongoimport --db wcm-local --collection content --file /fixtures/content.json && \
     mongoimport --db wcm-local --collection licenses --file /fixtures/licenses.json && \
     mongoimport --db wcm-local --collection lists --file /fixtures/lists.json && \
     mongoimport --db wcm-local --collection properties --file /fixtures/properties.json && \
     mongoimport --db wcm-local --collection videos --file /fixtures/videos.json)

C'est probablement la façon la plus propre de le faire.

* ANCIENNE VOIE *

J'ai créé un script shell avec mes commandes. Dans ce cas, je voulais démarrer mongodet exécuter, mongoimportmais appeler mongodvous empêche d'exécuter le reste.

docker-compose.yaml :

version: '3'

services:
  mongo:
    container_name: mongo
    image: mongo:3.2.12
    ports:
      - "27017:27017"
    volumes:
      - ./fixtures:/fixtures
      - ./deploy:/deploy
      - ../.data/mongodb:/data/db
    command: sh /deploy/local/start_mongod.sh

start_mongod.sh :

mongod --fork --syslog && \
mongoimport --db wcm-local --collection clients --file /fixtures/clients.json && \
mongoimport --db wcm-local --collection configs --file /fixtures/configs.json && \
mongoimport --db wcm-local --collection content --file /fixtures/content.json && \
mongoimport --db wcm-local --collection licenses --file /fixtures/licenses.json && \
mongoimport --db wcm-local --collection lists --file /fixtures/lists.json && \
mongoimport --db wcm-local --collection properties --file /fixtures/properties.json && \
mongoimport --db wcm-local --collection videos --file /fixtures/videos.json && \
pkill -f mongod && \
sleep 2 && \
mongod

Donc, cette fourche mongo, fait de la monogimportation puis tue le mongo fourchu qui est détaché, et le redémarre sans se détacher. Je ne sais pas s'il existe un moyen de s'attacher à un processus fourchu, mais cela fonctionne.

REMARQUE: Si vous souhaitez strictement charger des données de base de données initiales, voici la façon de procéder:

mongo_import.sh

#!/bin/bash
# Import from fixtures

# Used in build and docker-compose mongo (different dirs)
DIRECTORY=../deploy/local/mongo_fixtures
if [[ -d "/fixtures" ]]; then
    DIRECTORY=/fixtures
fi
echo ${DIRECTORY}

mongoimport --db wcm-local --collection clients --file ${DIRECTORY}/clients.json && \
mongoimport --db wcm-local --collection configs --file ${DIRECTORY}/configs.json && \
mongoimport --db wcm-local --collection content --file ${DIRECTORY}/content.json && \
mongoimport --db wcm-local --collection licenses --file ${DIRECTORY}/licenses.json && \
mongoimport --db wcm-local --collection lists --file ${DIRECTORY}/lists.json && \
mongoimport --db wcm-local --collection properties --file ${DIRECTORY}/properties.json && \
mongoimport --db wcm-local --collection videos --file ${DIRECTORY}/videos.json

Les fichiers mongo_fixtures / *. json ont été créés via la commande mongoexport.

docker-compose.yaml

version: '3'

services:
  mongo:
    container_name: mongo
    image: mongo:3.2.12
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db:cached
      - ./deploy/local/mongo_fixtures:/fixtures
      - ./deploy/local/mongo_import.sh:/docker-entrypoint-initdb.d/mongo_import.sh


volumes:
  mongo-data:
    driver: local

Si vous devez exécuter plusieurs processus démon, il est suggéré dans la documentation Docker d'utiliser Supervisord en mode non détaché pour que tous les sous-démons soient envoyés vers la sortie standard.

À partir d'une autre question SO, j'ai découvert que vous pouvez rediriger la sortie des processus enfants vers la sortie standard. De cette façon, vous pouvez voir toutes les sorties!

Pour exécuter plusieurs commandes dans le fichier docker-compose à l'aide de bash -c.

command: >
    bash -c "python manage.py makemigrations
    && python manage.py migrate
    && python manage.py runserver 0.0.0.0:8000"

Source: https://intellipaat.com/community/19590/docker-run-multiple-commands-using-docker-compose-at-once?show=19597#a19597

Utilisez un outil tel que l'attendre ou dockerize . Ce sont de petits scripts wrapper que vous pouvez inclure dans l'image de votre application. Ou écrivez votre propre script wrapper pour exécuter des commandes plus spécifiques à l'application. selon: https://docs.docker.com/compose/startup-order/

J'ai rencontré cela en essayant de configurer mon conteneur jenkins pour créer des conteneurs docker en tant qu'utilisateur jenkins.

Je devais toucher le fichier docker.sock dans le Dockerfile car je le lierai plus tard dans le fichier docker-compose. Sauf si je l'ai touché en premier, il n'existait pas encore. Cela a fonctionné pour moi.

Dockerfile:

USER root
RUN apt-get update && \
apt-get -y install apt-transport-https \
ca-certificates \
curl \
software-properties-common && \
curl -fsSL https://download.docker.com/linux/$(. /etc/os-release; 
echo "$ID")/gpg > /tmp/dkey; apt-key add /tmp/dkey && \
add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/$(. /etc/os-release; echo "$ID") \
$(lsb_release -cs) \
stable" && \
apt-get update && \
apt-get -y install docker-ce
RUN groupmod -g 492 docker && \
usermod -aG docker jenkins  && \
touch /var/run/docker.sock && \
chmod 777 /var/run/docker.sock

USER Jenkins

docker-compose.yml:

version: '3.3'
services:
jenkins_pipeline:
    build: .
    ports:
      - "8083:8083"
      - "50083:50080"
    volumes:
        - /root/pipeline/jenkins/mount_point_home:/var/jenkins_home
        - /var/run/docker.sock:/var/run/docker.sock

essayez d'utiliser ";" pour séparer les commandes si vous êtes dans les versions deux, par exemple

command: "sleep 20; echo 'a'"