Korzystanie z Docker-Compose: sposób wykonywania wielu poleceń

Chcę zrobić coś takiego, w którym mogę uruchamiać wiele poleceń w kolejności.

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

Zrozumiałem, użyj bash -c.

Przykład:

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

Ten sam przykład w multiliniach:

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

Lub:

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

Przed uruchomieniem uruchamiam rzeczy takie jak migracje w osobnym efemerycznym kontenerze, tak jak (uwaga, plik komponowania musi być typu „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

Pomaga to w utrzymaniu czystości i oddzielności. Dwie rzeczy do rozważenia:

1. Musisz upewnić się, że sekwencja uruchamiania jest poprawna (przy użyciu depend_on)

2. chcesz uniknąć wielu kompilacji, które osiąga się przez oznaczenie go za pierwszym razem przy użyciu kompilacji i obrazu; możesz wtedy odwoływać się do obrazu w innych pojemnikach

Polecam używanie shw przeciwieństwie do, bashponieważ jest łatwiej dostępne na większości obrazów opartych na Uniksie (alpine itp.).

Oto przykład 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"

Spowoduje to wywołanie następujących poleceń w kolejności:

• python manage.py wait_for_db - poczekaj, aż baza danych będzie gotowa
• python manage.py migrate - uruchom wszelkie migracje
• python manage.py runserver 0.0.0.0:8000 - uruchom mój serwer programistyczny

To działa dla mnie:

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 próbuje wyzerować zmienne przed uruchomieniem polecenia, więc jeśli chcesz, aby bash obsługiwał zmienne, musisz uciec od znaków dolara poprzez ich podwojenie ...

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

... w przeciwnym razie pojawi się błąd:

Niepoprawny format interpolacji dla opcji „polecenie” w usłudze „WWW”:

Możesz użyć punktu wejścia tutaj. punkt wejścia w oknie dokowanym jest wykonywany przed poleceniem, podczas gdy polecenie jest domyślnym poleceniem, które należy uruchomić przy uruchomieniu kontenera. Tak więc większość aplikacji na ogół przeprowadza procedurę instalacji w pliku punktu wejścia, aw ostatnim zezwala na uruchomienie polecenia.

stwórz plik skryptu powłoki jako docker-entrypoint.sh(nazwa nie ma znaczenia) z następującą zawartością.

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

w pliku docker-compose.yml użyj go entrypoint: /docker-entrypoint.shi zarejestruj polecenie jako command: python manage.py runserver 0.0.0.0:8000 PS: nie zapomnij skopiować docker-entrypoint.shwraz z kodem.

Inny pomysł:

Jeśli, tak jak w tym przypadku, budujesz kontener, po prostu umieść w nim skrypt startowy i uruchom go za pomocą polecenia. Lub zamontuj skrypt startowy jako wolumin.

* AKTUALIZACJA *

Uznałem, że najlepszym sposobem na uruchomienie niektórych poleceń jest napisanie niestandardowego pliku Docker, który robi wszystko, co chcę, zanim oficjalny plik CMD zostanie uruchomiony z obrazu.

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)

Jest to prawdopodobnie najczystszy sposób na zrobienie tego.

* STARA DROGA *

Za pomocą moich poleceń utworzyłem skrypt powłoki. W tym przypadku chciałem zacząć mongodi uruchomić, mongoimportale wywołanie mongodblokuje ci uruchomienie pozostałych.

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

Więc to rozwidla mongo, wykonuje monogimport, a następnie zabija rozwidlone mongo, które jest odłączone, i uruchamia je ponownie bez odłączania. Nie jestem pewien, czy istnieje sposób na dołączenie do rozwidlonego procesu, ale to działa.

UWAGA: Jeśli chcesz ściśle załadować początkowe dane bazy danych, możesz to zrobić w następujący sposób:

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 pliki zostały utworzone za pomocą komendy 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

Jeśli potrzebujesz uruchomić więcej niż jeden proces demona, w dokumentacji Dockera jest sugestia, aby używać Supervisord w trybie odłączonym, aby wszystkie pod-demony były wysyłane do standardowego wyjścia.

Z innego pytania SO odkryłem, że możesz przekierować dane wyjściowe procesów potomnych na standardowe wyjście. W ten sposób możesz zobaczyć wszystkie dane wyjściowe!

Aby uruchomić wiele poleceń w pliku tworzenia dokerów za pomocą bash -c.

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

Źródło: https://intellipaat.com/community/19590/docker-run-multiple-commands-using-docker-compose-at-once?show=19597#a19597

Użyj narzędzia, takiego jak czekanie na niego lub dokowanie . Są to małe skrypty otoki, które można dołączyć do obrazu aplikacji. Lub napisz własny skrypt opakowania, aby wykonać polecenia bardziej specyficzne dla aplikacji. zgodnie z: https://docs.docker.com/compose/startup-order/

Natknąłem się na to, próbując skonfigurować mój kontener Jenkins, aby budować kontenery dokujące jako użytkownik Jenkins.

Musiałem dotknąć pliku docker.sock w pliku Docker, ponieważ łączę go później w pliku komponowania dokera. Chyba że najpierw go dotknąłem, jeszcze nie istniał. To zadziałało dla mnie.

Plik Docker:

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

spróbuj użyć „;” aby rozdzielić polecenia, jeśli jesteś w dwóch wersjach, np

command: "sleep 20; echo 'a'"