web-dev-qa-db-fra.com

Exécution de plusieurs projets en utilisant docker, chacun fonctionnant avec docker-compose

Nous utilisons une approche microservices pour construire notre produit. Nous utilisons des projets dont chacun utilise docker-compose pour s'exécuter. Le problème est qu'en environnement de développement, si nous voulons modifier les codes de plusieurs projets et tester les codes développés, nous devons exécuter les projets séparément et les lier manuellement.

Nous voulons maintenant créer un kit de développement qui clone des projets, les exécute ensemble et gère les liens. Docker-compose peut-il gérer plusieurs fichiers docker-composer? Sinon, existe-t-il un outil suffisant pour le faire pour nous? Ou existe-t-il une approche recommandée pour notre objectif?

EDIT: Par exemple, nous avons deux projets: PROJECT_A et PROJECT_B. Chacun a son propre fichier docker-compose.yml et chacun a besoin de postgresql pour fonctionner. Nous avons docker-compose.yml dans PROJECT_A comme ceci:

db:
    image: postgres:9.4
    ports:
      - "5432"

project_a:
    build: .
    command: python2.7 main.py
    links:
        - db

Et nous avons docker-compose.yml dans PROJECT_B comme ceci:

db:
    image: postgres:9.4
    ports:
      - "5432"

project_b:
    build: .
    command: python2.7 main.py
    links:
        - db

Chaque projet peut être exécuté séparément et fonctionne correctement. Mais si nous voulons changer l’API entre PROJECT_A et PROJECT_B, nous devons exécuter les deux projets et les lier ensemble pour tester notre code. Maintenant, nous voulons écrire un projet de kit de développement qui puisse exécuter les deux projets et les lier si nécessaire. Quelle est la meilleure approche pour faire cela?

dockerdevelopment-environmentdocker-composemicroservices
12
Mehran Akhavan

Vous pouvez le faire en combinant des services de plusieurs fichiers à l’aide de la fonction extends de docker-compose. Placez vos projets dans un emplacement bien défini et faites-les référence à l'aide de chemins relatifs:

../
├── foo/
│   └── docker-compose.yml
└── bar/
    └── docker-compose.yml

foo/docker-compose.yml:

base:
    build: .

foo:
    extends:
        service: base
    links:
        - db

db:
    image: postgres:9

Si vous voulez tester ce projet lui-même, vous feriez quelque chose comme:

Sudo docker-compose up -d foo

Créer foo_foo_1

bar/docker-compose.yml:

foo:
    extends:
        file: ../foo/docker-compose.yml
        service: base
    links:
        - db

bar:
    build: .
    extends:
        service: base
    links:
        - db
        - foo

db:
    image: postgres:9

Vous pouvez maintenant tester les deux services avec:

Sudo docker-compose up -d bar

Création de bar_foo_1 
Création de bar_bar_1

7
z0r

Je ne suis pas sûr à 100% de votre question, alors ce sera une réponse large. 

1) Tout peut se trouver dans le même fichier de composition s’il s’exécute sur le même ordinateur ou le même cluster de serveurs.

#proxy
haproxy:
  image: haproxy:latest
  ports:
    - 80:80


#setup 1
ubuntu_1:
  image: ubuntu
  links:
    - db_1:mysql
  ports:
    - 80

db1:
  image: ubuntu
  environment:
    MYSQL_ROOT_PASSWORD: 123


#setup 2
ubuntu_2:
   image: ubuntu
   links:
     - db_2:mysql
   ports:
    - 80

db2:
  image: ubuntu
  environment:
    MYSQL_ROOT_PASSWORD: 123

Il est également possible de combiner plusieurs fichiers yml like
$docker-compose -f [File A].yml -f [File B].yml up -d

2) Chaque conteneur de la construction peut être contrôlé séparément avec compose.
$docker-compose stop/start/build/ ubuntu_1

3) Utiliser $docker-compose build it ne reconstruira que les modifications apportées.

Voici d'autres informations qui pourraient être utiles https://docs.docker.com/compose/extends/#extending-services

Si aucune des réponses ci-dessus n’est correcte, veuillez donner un exemple de construction.

3
Mathias Asberg

Ceci est notre approche pour tous ceux qui ont le même problème:

Chacun de nos projets a maintenant un docker-composition qui peut être exécuté de manière autonome. Nous avons un autre projet appelé «kit de développement» qui clone des projets nécessaires et les stocke dans un répertoire. Nous pouvons exécuter nos projets en utilisant une commande similaire à:

python controller.py --run projectA projectB

Il exécute chaque projet à l'aide de la commande docker-compose up. Ensuite, lorsque tous les projets sont opérationnels, il commence à ajouter tous les autres projets à l'adresse IP du docker principal en les ajoutant aux ips/etc/hosts à l'aide des commandes suivantes:

# getting contaier id of projectA and projectB
CIDA = commands.getoutput("docker-compose ps -q %s" % projectA)
CIDB = commands.getoutput("docker-compose ps -q %s" % projectB)
# getting ip of container projectA
IPA = commands.getoutput("docker inspect --format '{{ .NetworkSettings.IPAddress }}' %s" % CIDA)

Maintenant, pour envoyer des demandes de projectB à projectA, il suffit de définir projectA IP comme "projectA" dans les paramètres de projectB.

1
Mehran Akhavan