mongodb - hub - ¿Cómo sembro una base de datos mongo usando docker-compose?

docker mongodb versions

Question

Estoy tratando de distribuir un conjunto de aplicaciones conectadas que se ejecutan en varios contenedores vinculados que incluyen una base de datos mongo que se requiere para:

• ser distribuido conteniendo algunos datos semilla;
• Permitir a los usuarios agregar datos adicionales.

Idealmente, los datos también se conservarán en un contenedor de volumen de datos vinculado.

Puedo obtener los datos en el contenedor de mongo usando una instancia de base de mongo que no monta ningún volumen (imagen dockerhub: psychemedia/mongo_nomount ; esto es esencialmente el Dockerfile base mongo sin la declaración VOLUME /data/db ) y una configuración Dockerfile junto las líneas de:

ADD . /files
WORKDIR /files
RUN mkdir -p /data/db && mongod --fork --logpath=/tmp/mongodb.log && sleep 20 && /
mongoimport  --db testdb --collection testcoll  --type csv --headerline --file ./testdata.csv  #&& mongod --shutdown

donde ./testdata.csv está en el mismo directorio ( ./mongo-with-data ) que el Dockerfile.

Mi archivo de configuración docker-compose incluye lo siguiente:

mongo:
  #image: mongo
  build: ./mongo-with-data
  ports:
    - "27017:27017"
  #Ideally we should be able to mount this against a host directory
  #volumes:
  #  - ./db/mongo/:/data/db
  #volumes_from:
  #  - devmongodata

#devmongodata:
#    command: echo created
#    image: busybox
#    volumes: 
#       - /data/db

Cada vez que intento montar un VOLUMEN parece que los datos sembrados originales, que se almacenan en /data/db , se eliminan. Supongo que cuando se monta un volumen en /data/db , reemplaza todo lo que hay actualmente.

Dicho esto, la guía de usuario de Docker sugiere que: Los volúmenes se inicializan cuando se crea un contenedor. Si la imagen base del contenedor contiene datos en el punto de montaje especificado, ¿los datos existentes se copian en el nuevo volumen tras la inicialización del volumen ? Entonces, ¿esperaba que los datos persistieran si colocaba el comando VOLUME después del comando RUN inicializado?

Entonces, ¿qué estoy haciendo mal?

La visión a largo plazo es que quiero automatizar la construcción de varios contenedores vinculados, y luego distribuir un archivo YAML Vagrantfile por Vagrantfile / docker que activará un conjunto de aplicaciones vinculadas, que incluye una base de datos mongo pre-sembrada con un (parcialmente pre -poblada) contenedor de datos persistentes.

Answer 1

Aquí hay un resumen de cómo estamos usando contenedores desechables para limpiar y sembrar imágenes https://blog.ardoq.com/dynamic-database-seeding-with-docker

Answer 2

Hago esto usando otro contenedor acoplable cuyo único propósito es sembrar mongo, luego salir. Sospecho que esta es la misma idea que ebaxt , pero cuando estaba buscando una respuesta a esto, solo quería ver un ejemplo rápido y sucio, pero directo. Entonces aquí está el mío:

docker-compose.yml

mongodb:
  image: mongo
  ports:
    - "27017:27017"

mongo-seed:
  build: ./mongo-seed
  links:
    - mongodb

# my webserver which uses mongo (not shown in example)
webserver:
  build: ./webserver
  ports:
    - "80:80"
  links:
    - mongodb

mongo-seed / Dockerfile

FROM mongo

COPY init.json /init.json
CMD mongoimport --host mongodb --db reach-engine --collection MyDummyCollection --type json --file /init.json --jsonArray

mongo-seed / init.json

[
  {
    "name": "Joe Smith",
    "email": "[email protected]",
    "age": 40,
    "admin": false
  },
  {
    "name": "Jen Ford",
    "email": "[email protected]",
    "age": 45,
    "admin": true
  }
]

Answer 3

He encontrado útil usar Docker Custom Images y usar volúmenes, en lugar de crear otro contenedor para la siembra.

Estructura de archivo

.
├── docker-compose.yml
├── mongo
│   ├── data
│   ├── Dockerfile
│   └── init-db.d
│       └── seed.js

Cada ubicación de archivo mencionada en Dockerfile / docker-compose.yml , es relativa a la ubicación de docker-compose.yml

DOCKERFILE

FROM mongo:3.6

COPY ./init-db.d/seed.js /docker-entrypoint-initdb.d

docker-compose.yml

version: ''3''

services:
  db:
    build: ./mongo
    restart: always
    volumes:
      - ./mongo/data:/data/db #Helps to store MongoDB data in `./mongo/data`
    environment:
      MONGO_INITDB_ROOT_USERNAME: {{USERNAME}}
      MONGO_INITDB_ROOT_PASSWORD: {{PWD}}
      MONGO_INITDB_DATABASE: {{DBNAME}}

seed.js

// Since Seeding in Mongo is done in alphabetical order... It''s is important to keep
// file names alphabetically ordered, if multiple files are to be run.

db.test.drop();
db.test.insertMany([
  {
    _id: 1,
    name: ''Tensor'',
    age: 6
  },
  {
    _id: 2,
    name: ''Flow'',
    age: 10
  }
])

docker-entrypoint-initdb.d se puede usar para crear diferentes usuarios y cosas relacionadas con la administración de mongodb, solo cree un orden alfabético llamado js-script para createUser etc.

Para obtener más detalles sobre cómo personalizar el servicio MongoDB Docker, lea this

Además, es bueno mantener sus contraseñas y nombres de usuario seguros de Public, NO inserte credenciales en git público , en su lugar use Docker Secrets . Lea también este tutorial sobre secretos

Tenga en cuenta que no es necesario entrar en modo docker-swarm para usar secretos. Componer archivos también admite secretos. Mira this

Los secretos también se pueden usar en MongoDB Docker Services

Answer 4

Para responder mi propia pregunta:

• archivo YAML simple para crear un contenedor mongo simple vinculado a un contenedor de volumen de datos, activado por Vagrant docker compose.
• en el Vagrantfile, codifique a lo largo de las líneas de:

config.vm.provision :shell, :inline => <<-SH docker exec -it -d vagrant_mongo_1 mongoimport --db a5 --collection roads --type csv --headerline --file /files/AADF-data-minor-roads.csv SH

para importar los datos.

Empaque la caja.

Distribuir la caja.

Para el usuario, un archivo Vagrantfile simple para cargar la caja y ejecutar una secuencia de comandos YAML compuesta por docker para iniciar los contenedores y montar el mongo db contra el contenedor de volumen de datos.

Answer 5

Puede usar esta image que proporciona el contenedor acoplable para muchos trabajos (importación, exportación, volcado)

Mira el example usando docker-compose

Answer 6

Puede usar la imagen Mongo Seeding Docker .

¿Por qué?

• Tienes la imagen de Docker lista para usar
• No está vinculado a archivos JSON: también se admiten archivos JavaScript y TypeScript (incluida la validación opcional del modelo con TypeScript)

Ejemplo de uso con Docker Compose:

version: ''3''
services:
  database:
    image: ''mongo:3.4.10''
    ports:
    - ''27017:27017''
  api:
    build: ./api/
    command: npm run dev
    volumes: 
    - ./api/src/:/app/src/
    ports:
    - ''3000:3000''
    - ''9229:9229''
    links:
    - database
    depends_on:
    - database
    - data_import
    environment: 
    - &dbName DB_NAME=dbname
    - &dbPort DB_PORT=27017 
    - &dbHost DB_HOST=database
  data_import:
    image: ''pkosiec/mongo-seeding:3.0.0''
    environment:
    - DROP_DATABASE=true
    - REPLACE_ID=true
    - *dbName
    - *dbPort
    - *dbHost
    volumes:
    - ./data-import/dev/:/data-import/dev/
    working_dir: /data-import/dev/data/
    links:
    - database
    depends_on:
    - database

Descargo de responsabilidad: soy el autor de esta biblioteca.

Answer 7

Respuesta actual basada en la respuesta de @Jeff Fairley y actualizada de acuerdo con los nuevos documentos de Docker

docker-compose.yml

version: "3.5"

services:
  mongo:
    container_name: mongo_dev
    image: mongo:latest
    ports:
      - 27017:27017
    networks:
      - dev

  mongo_seed:
    container_name: mongo_seed
    build: .
    networks:
      - dev
    depends_on:
      - mongo

networks:
  dev:
    name: dev
    driver: bridge

Dockerfile

FROM mongo:latest
COPY elements.json /elements.json
CMD mongoimport --host mongo --db mendeleev --collection elements --drop --file /elements.json --jsonArray

Probablemente necesite reconstruir las imágenes actuales.

Answer 8

Vale la pena mirar esta respuesta: https://.com/a/42917632/5209935

La idea básica es que la imagen de stock de mongo tiene un punto de entrada especial que puede sobrecargar para proporcionar un script que siembra la base de datos.