Verwenden von Docker-Compose zum Ausführen mehrerer Befehle

Ich möchte so etwas tun, wo ich mehrere Befehle nacheinander ausführen kann.

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

Ich habe es herausgefunden, benutze bash -c.

Beispiel:

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

Gleiches Beispiel in mehreren Zeilen:

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

Oder:

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

Ich führe Pre-Startup-Inhalte wie Migrationen in einem separaten kurzlebigen Container aus (beachten Sie, dass die Compose-Datei vom Typ '2' sein muss):

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

Dies hilft, die Dinge sauber und getrennt zu halten. Zwei Dinge zu beachten:

1. Sie müssen die richtige Startreihenfolge sicherstellen (mit abhängigen_on)

2. Sie möchten mehrere Builds vermeiden, indem Sie sie beim ersten Mal mit Build und Image markieren. Sie können dann auf das Bild in anderen Containern verweisen

Ich empfehle die Verwendung shim Gegensatz zu, bashda es auf den meisten Unix-basierten Bildern (alpine usw.) leichter verfügbar ist.

Hier ist ein Beispiel 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"

Dadurch werden die folgenden Befehle der Reihe nach aufgerufen:

• python manage.py wait_for_db - Warten Sie, bis die Datenbank fertig ist
• python manage.py migrate - Führen Sie alle Migrationen durch
• python manage.py runserver 0.0.0.0:8000 - Starten Sie meinen Entwicklungsserver

Das funktioniert bei mir:

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 versucht, Variablen zu dereferenzieren, bevor der Befehl ausgeführt wird. Wenn Sie also möchten, dass bash Variablen verarbeitet, müssen Sie den Dollarzeichen entkommen, indem Sie sie verdoppeln ...

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

... sonst erhalten Sie eine Fehlermeldung:

Ungültiges Interpolationsformat für die Option "Befehl" im Dienst "Web":

Hier können Sie den Einstiegspunkt verwenden. Der Einstiegspunkt im Docker wird vor dem Befehl ausgeführt, während der Befehl der Standardbefehl ist, der beim Starten des Containers ausgeführt werden soll. Daher führen die meisten Anwendungen im Allgemeinen Setup-Prozeduren in der Einstiegspunktdatei aus und in der letzten erlauben sie die Ausführung des Befehls.

Erstellen Sie eine Shell-Skriptdatei kann wie docker-entrypoint.shfolgt sein (Name spielt keine Rolle) mit folgenden Inhalten.

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

Verwenden Sie es in der Datei docker-compose.yml mit entrypoint: /docker-entrypoint.shund registrieren Sie den Befehl als command: python manage.py runserver 0.0.0.0:8000 PS: Vergessen Sie nicht, docker-entrypoint.shzusammen mit Ihrem Code zu kopieren .

Eine andere Idee:

Wenn Sie wie in diesem Fall den Container erstellen, platzieren Sie einfach ein Startskript darin und führen Sie dieses mit dem Befehl aus. Oder hängen Sie das Startskript als Volume ein.

* UPDATE *

Ich dachte, der beste Weg, einige Befehle auszuführen, besteht darin, eine benutzerdefinierte Docker-Datei zu schreiben, die alles tut, was ich will, bevor das offizielle CMD aus dem Image ausgeführt wird.

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)

Dies ist wahrscheinlich der sauberste Weg, dies zu tun.

* ALTER WEG *

Ich habe mit meinen Befehlen ein Shell-Skript erstellt. In diesem Fall wollte ich starten mongodund ausführen, mongoimportaber ein Anruf mongodhindert Sie daran, den Rest auszuführen .

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

Dieser Gabel-Mongo führt also einen Monogimport durch und tötet dann den abgetrennten Gabel-Mongo und startet ihn erneut, ohne sich zu lösen. Ich bin mir nicht sicher, ob es eine Möglichkeit gibt, eine Verbindung zu einem gegabelten Prozess herzustellen, aber dies funktioniert.

HINWEIS: Wenn Sie unbedingt einige anfängliche Datenbankdaten laden möchten, gehen Sie folgendermaßen vor:

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

mongo_fixtures / *. json-Dateien wurden mit dem Befehl mongoexport erstellt.

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

Wenn Sie mehr als einen Daemon-Prozess ausführen müssen, wird in der Docker-Dokumentation empfohlen, Supervisord in einem nicht getrennten Modus zu verwenden, damit alle Sub-Daemons auf dem Standard ausgegeben werden.

Bei einer anderen SO-Frage habe ich festgestellt, dass Sie die Ausgabe der untergeordneten Prozesse an stdout umleiten können. Auf diese Weise können Sie die gesamte Ausgabe sehen!

So führen Sie mehrere Befehle in der Docker-Compose-Datei aus bash -c:

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

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

Verwenden Sie ein Tool wie "Wait-for-It" oder " Dockerize" . Dies sind kleine Wrapper-Skripte, die Sie in das Image Ihrer Anwendung aufnehmen können. Oder schreiben Sie Ihr eigenes Wrapper-Skript, um anwendungsspezifischere Befehle auszuführen. laut: https://docs.docker.com/compose/startup-order/

Ich bin darauf gestoßen, als ich versucht habe, meinen Jenkins-Container so einzurichten, dass Docker-Container als Jenkins-Benutzer erstellt werden.

Ich musste die Datei docker.sock in der Docker-Datei berühren, da ich sie später in der Docker-Compose-Datei verknüpfe. Sofern ich es nicht zuerst berührt habe, existierte es noch nicht. Das hat bei mir funktioniert.

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

versuche es mit ";" um die Befehle zu trennen, wenn Sie sich in zwei Versionen befinden, z

command: "sleep 20; echo 'a'"