Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Curso de Docker

Curso de Docker

Guido Vilariño

Guido Vilariño

Compose en equipo: override

25/32
Recursos

Aportes 36

Preguntas 11

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Hace años, escribí un tutorial en el blog de como configurar docker con Django por si le quieren echar un ojo 👀

Comandos:
$ touch docker-compose.override.yml (creo el archivo override)
$ docker-compose up -d (crea los servicios/contenedores)
$ docker-compose exec app bash (entro al bash del contenedor app)
$ docker-compose ps (veo los contenedores del compose)
$ docker-compose up -d --scale app=2 (escalo dos instancias de app, previamente tengo que definir un rango de puertos en el archivo compose)
$ docker-compose down (borro todo lo creado con compose)

pueden tener diferentes overrides por enetorno por ejemplo:

  • docker-compose.override.yml para development
  • docker-compose.staging.yml para staging
  • docker-compose.production.yml para production

Y debes correrlos de la siguiente forma:

para development:

docker-compose up

para staging:

docker-compose \
	-f docker-compose.ym \
	-f docker-compose.staging.yml \
	up

para production:

docker-compose \
	-f docker-compose.yml \
	-f docker-compose.production.yml \
	up

docker-compose.override.yml es un archivo que se encarga de sobreescribir tu configuración de docker-compose.yml , se puede usar para tener segura tu configuración y para no guardar los cambios en el repositorio de git.
Un equivalente podría ser los archivos de declaración de variables de entorno, donde hay un archivo .env declarando su nombre y valor, y hay una copia .env.example con solo las variables sin valor. En .gitignore se declara que los cambios en .env no serán guardados, pero mandamos el archivo de ejemplo al repositorio.

Como implementarlo sobre diferentes ambientes:

Local, dev, qa, prod.

https://medium.com/it-dead-inside/making-sense-of-docker-compose-overrides-efb757460d64

Problema en la colaboracion con docker-compose.override.yml, sirve para personalizar o hacer pequeños cambios propios para nuestro ambiente sobre el original sin alterar ese archivo.

touch docker-compose.override.yml

nano docker-compose.override.yml
######docker-compose.override.yml######

version: "3.8"
services:
  app:
    build: .
    environment:
      UNA_VARIABLE: "Hola platzi"

#######################################
nano docker-compose.yml
######docker-compose.yml######

version: "3.8"
services:
  app:
    image: platziapp
    environment:
      MONGO_URL: "mongodb://db:27017/test"
    depends_on:
      - db
    ports:
      - "3000:3000"
  db:
    image: mongo

#######################################
docker-compose up -d

– Crear dos instancias de app, es decir dos contenedores

nano docker-compose.yml
######docker-compose.yml######

version: "3.8"
services:
  app:
    image: platziapp
    environment:
      MONGO_URL: "mongodb://db:27017/test"
    depends_on:
      - db
    ports:
      - "3000-3001:3000"
  db:
    image: mongo

#######################################
docker-compose up -d --scale app=2

docker-compose ps

Para disponer de múltiples contenedores (escalar) de un mismo servicio, se requiere habilitar un rango de puertos en el host (máquina donde corre Docker), se realiza mediante la instrucción puerto [PUERTO-PUERTO]. Para escalar un servicio se puede usar el flag “–scale” en el comando up:

docker-compose up -d --scale [nameService]=[numberContainers]

También se dispone del comando scale:

docker-compose scale [service]=[number] [service2]=[number2]

Fuente: https://docs.docker.com/compose/reference/scale/

La verdad no conocia override

25. Compose en equipo: override

Funcionamiento de un archivo override.yml

Contexto del archivo.override.yml
El archivo.yml que utiliza docker compose normalmente iría versionando, pero surge un problema, el problema es que a veces se realizan cambios en el archivo.yml (archivo base) para probar ciertas cosas, y luego se desea hacer commit en el proyecto sin que se commitee los cambios en el archivo.yml (archivo base). La solución que propone docker es utilizar un archivo.override.yml que contenga esas variaciones del archivo.yml (archivo base). Al momento de ejecutar docker-compose, este se da cuenta qué, en nuestro archivo.override.yml va a sustituir o tomar ciertas configuraciones de nuestro archivo.yml (archivo base)

¿Qué es un archivo.override.yml?
Es un archivo de tipo compose.file (archivo.yml) que puede realizar cambios a nuestro archivo compuse original.
¿Cómo funciona un archiv.override.yml?
Por ejemplo: se puede agregar variables de entorno en ambos archivo y lo que hará docker-compose es una especie de merge, como ocurre en git, es decir creará ambas variables de entorno. Es decir agregará se puede realizar un build también mientras en el archivo base

  • funcionamiento de los port
    En el caso de crear los puertos, si es recomendable hacerlo solamente en nuestro archivo.yml (archivo base). Esto se debe a que los puertos se procesan en estapas distintas

  • funcionamiento de depen_on:
    Este caso también lo tomas del archivo.yml (archivo base)

Pasos para configurar un archivo.override.yml con el ejemplo anterior

  1. Crear el archivo con el nombre docker-compose.override.yml
  2. Verificar que el archivo existe
  3. Configurar el anterior archivo base como estaba e introientelo siguiente:
  • Los puertos (port) y las dependencias (depend_on) deberían ir en el archivo base y el archivo orverride los tomará de allí
  • Si declaramos variables de entorno (enviroment) tanto en nuestro archivo base (docker-compose.yml) y en nuestro archivo override (docker-compose.override.yml), lo que hará docker compose es que tomará las dos variables de entornos y las creara.
  • Otro punto importante es que tenemos en nuestro archivo base (doker-compose) un servicio con image y en un archivo override (docker-compose-override) un build. El nombre que tomará nuestro servicio será el nombre de la carpeta donde está y el nombre del servicio.

5.Luego levantar los servicios
6. Realizar la prueba en el navegador

Ejecución de lo pasos para configurar un archivo.override.yml con el ejemplo anterior

  1. $ touch docker-compose.override.yml
  2. $ ls -al



4. $ sudo docker-compose up -d
5. localhost:3000

Pasos para escalar contenedores
Existe la posibilidad de escalar los contenedores para realizar distintas pruebas para ello se utiliza los siguientes pasos

  1. Eliminamos los anteriores servicios para modificar el archivo base, añadiendo un rango de puertos
  2. En nuestro archivo docker-compose.yml en la sección de puerto definimos un rango de puerto para nuestros contenedores. La explicación es la siguiente: dos contenedores se asocian a un puerto físico, pero internamente cada contenedor tiene su propio puerto virtual. (Dos servicios no pueden escuchar en el mismo puerto físico)
  3. Levantamos los servicios escalándola a 2 instancias.
  4. Realizamos las pruebas en el navegador

++Ejecución de los pasos para escalar contenedores ++

  1. $ sudo docker-compuse down


3. $ sudo docker-compose up -d --scale container_platzi_app=2

–scale <nombre_del_servicio_a escalar>=2

  1. En una pestaña localhost:3000 , en otra pestaña localhost:3001

Un aporte pequeño cuando el profesor dic: “que el puerto se bindee”, esta palabra es una palabra en ingles que es bind que significa atar, o sea lo que quiere decir que atar o relacionar un puerto con otro

Understanding multiple Compose files

By default, Compose reads two files, a docker-compose.yml and an optional docker-compose.override.yml file. By convention, the docker-compose.yml contains your base configuration. The override file, as its name implies, can contain configuration overrides for existing services or entirely new services.

If a service is defined in both files, Compose merges the configurations using the rules described in Adding and overriding configuration.

To use multiple override files, or an override file with a different name, you can use the -f option to specify the list of files. Compose merges files in the order they’re specified on the command line.

When you use multiple configuration files, you must make sure all paths in the files are relative to the base Compose file (the first Compose file specified with -f). This is required because override files need not be valid Compose files. Override files can contain small fragments of configuration. Tracking which fragment of a service is relative to which path is difficult and confusing, so to keep paths easier to understand, all paths must be defined relative to the base file.

Fuente: https://docs.docker.com/compose/extends/

Para los usuarios de MacOS o linux, pueden configurar sus alias en el archivo ~/.bashrc. Solo hay que agregarlos al final del archivo. No importa si usan oh-my-bash.

alias fig="docker-compose"

Una analogía de este archivo es cuando tenemos el archivo de configuración de variables de entorno, conexiones a bd, etc y que lo ignoramos en el archivo .gitignore y así cada quien configura sus variables de acuerdo al ambiente, demasiado útil este archivo.

para los que tengan problema con el Scale lo mejor es dejar libre el puerto
p.ej

...//
services:
  app:
    image: platziapp
    environment:
      MONGO_URL: 'mongodb://db:27017/test'
    depends_on:
      - db
    ports:
      - '3000'
...//

En lo que llevo del curso, me quedo con la frase de: Una imágen es como una clase, y los contenedores son los objetos o instancias de esa clase

En versiones recientes docker-compose se ha integrado en el comando docker, por lo que podemos usarlo mediante

docker compose

Que recomendarias para medir las estadisticas de cada instancia?

Me gusto Override

Excelente herramienta colaborativa.

Me ocurrió que al especificar un rango de puertos en el docker compose.yml para usar el comando --scale, el docker compose me arrojaba un error diciendo que no podía alocar el segundo contenedor en el 2do puerto que le habilité. Para evitar este error pueden colocar en el apartado de ports en el yml solamente el puerto que se expondrá del contenedor. Docker asignará según entienda la cantidad de puertos que requiera para satisfacer tu necesidad de escalabilidad.

Una desventaja de esto es que no tienes control de que puerto será, y tampoco lo conocerás hasta que los contenedores se levanten. Una vez levantados con el docker compose ps puedes ver que puertos tomaron.

Compañeros, seguramente tendran problemas al ejecutar el comando

docker-compose up --scale app=2

debido a que el engine de docker-compose v2 es diferente a la v1 que es la que se usa en el curso, si quieren realizar este ejercicio, se puede ejecutar el siguiente comando

docker-compose disable-v2

al terminar lo recomendable es ejecutar el comando

docker-compose enable-v2

Si no queremos utilizar el archivo predefinido por docker-compose: docker-compose.override.yml. Se puede predefinir el nombre que deseamos utilizar e incluso crear uno que este más abajo de este, quedando así el archivo padre e hijo o abuelo, padre e hijo.

De esta manera podremos tener un archivo principal y archivos secundarios con las modificaciones necesarias para nuestro contenedor, sin afectar nuestro archivo docker-compose.yml

Para esto podemos utilizar la bandera -f. Un ejemplo de la utilización sería:

  • docker-compose -f docker-compose.yml -f docker-compose.admin.yml run backup_db

Para más información consultar:
https://docs.docker.com/compose/reference/

No deja claro si al hacer docker-compose down los datos que se hayan agregado a la base de datos se preservan, tengo entendido que al hacer el down destruye los contenedores de db y por tanto dado que no hay un bind mount o volumen donde se guarden los datos de la base, la base es borrada en cada ocasión.

You may run into this problem if you are using docker compose v2
https://github.com/docker/compose/issues/8530

¡Docker es increíble! Un amigo siempre me decía que amaba docker y yo no entendía por qué. Pero a través de este curso me he dado cuenta de lo genial y extremadamente útil que es esta herramienta.
¡Hasta ahora el curso 10/10 y el profe también!!

**Solución para el problema de colaboración con las modificaciones sobre el archivo de docker
**

**Compose Override: **es basicamente como un compose file, tiene otro nombre, sirve para personalizar o hacer cambios para nuestro ambiente, sin necesidad de alterar el compose file.

  1. Crear un nuevo archivo
touch docker-compose.override.yml

Es un compose, que puede cambiar algunas definiciones de nuestro compose original, se combina con el base, se puede volver a especificar nuevamente algo que este especificado en el compose base y docker al hacer el build hara un merge.

  • Hay cosas que no andan del todo bien, como por ejemplo ports.
  1. Escalar instancias
docker-compose up -d --scale app=2
  • Debemos dar un rango de puertos en el docker file
    ports:
      - "3000-3001:3000"
  1. dar de baja los servicios
docker-compose down

Esto del --scale y el .override.yml tambien es EXITO ROTUNDO, y no lo dijo.

Entendido scale = 1000

COMPOSE OVERRIDE
#crear contenedor
docker-compose up

#borrar contenedor
docker-compose down

#escalar compose
docker-compose up -d --scale <service-name>=<number>

automatización para los archivos que se tienen compartidos

generando herencia entre los archivos compose pero en el overrride que es como donde hacemos modificaciones personales sin tocar el compose, lo que genera configuraciones coustumizadas

Me parece chevere el hecho de que en docker se manejen conceptos de POO y de muchas herramientas, así uno logra entender en parte como todos estos paradigmas se aplican en tantas herramientas.

TIP.- Se puede usar un rango de puertos para simular el envío simultáneo a varios "frontends" desde una API/db para testear concurrencias, etc.

Buena clase

Genial!!!

😎

  • El archivo docker-compose.overwrite.yml, permite sobre-escribir algunos parámetros del archivo principal de docker-compose.yml. Lo podemos usar para customizar entre distintos ambientes.
  • docker-compose scale servicio=X, para escalar (incrementar o decrementar) un número de servicios X según lo necesite.
...
ports:
	- 3000-3010:3000  # para abrir un rango de puertos
...