Docker (6) : Swarns

1. Introducción. Swarn, swarn manager, node, worker

Estamos siguiendo las instrucciones de docs-docker.

Un "swarn" es un grupo de múltiples máquinas formando un cluster "dockerizado". Así una aplicación puede ser multi-container y multi-máquina.

Un "swarn" es un grupo de máquinas que están corriendo Docker y están unido formando un cluster.
Hay un "swarn manager" que ejecuta los comandos de docker. Las máquinas del "swarn" pueden ser físicas o lógicas. Después de unirse a un swarn, se les referirá como "nodes".

Los swarn managers son las únicas máquinas que pueden ejecutar órdenes docker. Tambien pueden autorizar a otras máquinas a unirse al swarn como "workers", sin que estas tengan la autoridad de un swarn manager frente a otras máquinas.

Docker puede correr en una máquina o varias máquinas (swarm mode). En este modo, nuestra máquina actua como swarm manager.

2. Prerequisito :Instalar Docker Compose

Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker multi-container. Se configura con YAML.

Descargamos el producto

sudo curl -L https://github.com/docker/compose/releases/download/1.19.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

Damos permisos de ejecución a los binarios

sudo chmod +x /usr/local/bin/docker-compose

Opcionalmente si utilizamos la bash podemos instalar el command completion que se instalara en /etc/bash_completion.d/ 

sudo curl -L https://raw.githubusercontent.com/docker/compose/1.19.0/contrib/completion/bash/docker-compose -o /etc/bash_completion.d/docker-compose

Basta con abrit un nuevo terminal para que funcione

3. Prerequisito :Instalar docker-machine

Para ello nos bajamos el software:

curl -L https://github.com/docker/machine/releases/download/v0.13.0/docker-machine-`uname -s`-`uname -m` >/tmp/docker-machine && \
sudo install /tmp/docker-machine /usr/local/bin/docker-machine

Comprobamos la instalación:

docker-machine version

Y sale:

docker-machine version 0.13.0, build 9ba6da9

4. Configurar el swarm

Para permitir el "swarm mode" y que nuestra máquina sea un "swarm manager":

docker swarm init

y que otras máquinas se unan como "workers" , se ejecuta en cada máquina (no olvidar el puntito):

docker swarm join .

Debemos tener instalado el Virtual Box de Oracle y creamos 2 máquinas virtuales myvm1 y myvm2

docker-machine create --driver virtualbox myvm1
docker-machine create --driver virtualbox myvm2




Y para la primera contesta:

Creating CA: /home/eduard/.docker/machine/certs/ca.pem
Creating client certificate: /home/eduard/.docker/machine/certs/cert.pem
Running pre-create checks...
(myvm1) Image cache directory does not exist, creating it at /home/eduard/.docker/machine/cache...
(myvm1) No default Boot2Docker ISO found locally, downloading the latest release...
(myvm1) Latest release for github.com/boot2docker/boot2docker is v17.12.1-ce
(myvm1) Downloading /home/eduard/.docker/machine/cache/boot2docker.iso from https://github.com/boot2docker/boot2docker/releases/download/v17.12.1-ce/boot2docker.iso...
(myvm1) 0%....10%....20%....30%....40%....50%....60%....70%....80%....90%....100%
Creating machine...
(myvm1) Copying /home/eduard/.docker/machine/cache/boot2docker.iso to /home/eduard/.docker/machine/machines/myvm1/boot2docker.iso...
(myvm1) Creating VirtualBox VM...
(myvm1) Creating SSH key...
(myvm1) Starting the VM...
(myvm1) Check network to re-create if needed...
(myvm1) Found a new host-only adapter: "vboxnet0"
Error creating machine: Error in driver during machine creation: This computer doesn't have VT-X/AMD-v enabled. Enabling it in the BIOS is mandatory

Como vemos sale un error que nos dice que hay que permitir el VT-x. Para ello rearrancamos el ordenador, entramos en la BIOS: Security-System Security- VT-x le damos a enable.

Voy a eliminar las máquinas:

docker-machine rm myvm1
docker-machine rm myvm2

Para listar las máquinas para ver si se han eliminado:

docker-machine ls

Y vuelvo a repetir los pasos para crear otra vez las máquinas

docker-machine create --driver virtualbox myvm1
docker-machine create --driver virtualbox myvm2

Y para la primera máquina sale:

Running pre-create checks...
Creating machine...
(myvm1) Copying /home/eduard/.docker/machine/cache/boot2docker.iso to /home/eduard/.docker/machine/machines/myvm1/boot2docker.iso...
(myvm1) Creating VirtualBox VM...
(myvm1) Creating SSH key...
(myvm1) Starting the VM...
(myvm1) Check network to re-create if needed...
(myvm1) Waiting for an IP...
Waiting for machine to be running, this may take a few minutes...
Detecting operating system of created instance...
Waiting for SSH to be available...
Detecting the provisioner...
Provisioning with boot2docker...
Copying certs to the local machine directory...
Copying certs to the remote machine...
Setting Docker configuration on the remote daemon...
Checking connection to Docker...
Docker is up and running!
To see how to connect your Docker Client to the Docker Engine running on this virtual machine, run: docker-machine env myvm1

Para listar las máquinas

docker-machine ls

Y sale:

NAME    ACTIVE   DRIVER       STATE     URL                         SWARM   DOCKER        ERRORS
myvm1   -        virtualbox   Running   tcp://192.168.99.102:2376           v17.12.1-ce   
myvm2   -        virtualbox   Running   tcp://192.168.99.103:2376           v17.12.1-ce   

Como vemos, las máquinas estan corriendo sin errores.

5. Inicializar el swarm y añadir nodes

La primera máquina actuará de "manager" y la segunda de "worker".

Vamos a decirle a la primera máquina que sea manager, para ello le enviamos la orden

docker-machine ssh myvm1 "docker swarm init --advertise-addr 192.168.99.102:2376"

Donde:

• docker-mashine ssh se utiliza para enviar comandos a una máquina
• docker swarm init .. es para hacerla manager
• 192.168.00.102:2376 es la URL de la primera máquina

Contesta:

Swarm initialized: current node (766cvl4wmayrwn7ly1tk92oi8) is now a manager.

To add a worker to this swarm, run the following command:

    docker swarm join --token SWMTKN-1-1yww21r6dv1ex4c48sumuahaqdyuxigxncalcj0j8mg5mudpre-d0rrehv96j8qc5xa7z61vji3p 192.168.99.102:2376

To add a manager to this swarm, run 'docker swarm join-token manager' and follow the instructions.

Dándonos el comando para añadir la segunda máquina como worker. Y ejecutamos el código amarillo pero enviándoselo por ssh a myvm2:

docker-machine ssh myvm2 "docker swarm join --token SWMTKN-1-1yww21r6dv1ex4c48sumuahaqdyuxigxncalcj0j8mg5mudpre-d0rrehv96j8qc5xa7z61vji3p 192.168.99.102:2376"

Y contesta:

Error response from daemon: rpc error: code = Internal desc = connection error: desc = "transport: remote error: tls: bad certificate"
exit status 1

Y según este link, hay que cambiar el puerto 2376 por 2377 y funciona

docker-machine ssh myvm2 "docker swarm join --token SWMTKN-1-1yww21r6dv1ex4c48sumuahaqdyuxigxncalcj0j8mg5mudpre-d0rrehv96j8qc5xa7z61vji3p 192.168.99.102:2377"

Contestando:

qdyuxigxncalcj0j8mg5mudpre-d0rrehv96j8qc5xa7z61vji3p 192.168.99.102:2377"
This node joined a swarm as a worker.

Si se quiere salir del swarn se puede teclear para cada nodo.

docker swarn leave

6. Desplegar la aplicacion en el swarm cluster

Para ejecutar comandos en una máquina virtual hacíamos uso de docker-mashine ssh, Pero ahora vamos a utilizar otra opción que es docker-mashine env <machine> , que nos pormite utilizar ficheros de configuración docker-compose.yml, para desplegar la aplicacion de forma remota sin tenerla que copiar a ninguna parte.

Vamos a ejecutar

 docker-machine env myvm1

y contesta:

export DOCKER_TLS_VERIFY="1"
export DOCKER_HOST="tcp://192.168.99.102:2376"
export DOCKER_CERT_PATH="/home/eduard/.docker/machine/machines/myvm1"
export DOCKER_MACHINE_NAME="myvm1"
# Run this command to configure your shell: 
# eval $(docker-machine env myvm1)

Y ejecutamos la orden de amarillo:

eval $(docker-machine env myvm1)

Y comprobamos que myvm1 es la máquina activa ya que tiene el asterisco

docker-machine ls

NAME    ACTIVE   DRIVER       STATE     URL                         SWARM   DOCKER        ERRORS
myvm1   *        virtualbox   Running   tcp://192.168.99.102:2376           v17.12.1-ce   
myvm2   -        virtualbox   Running   tcp://192.168.99.103:2376           v17.12.1-ce 

Vamos a desplegar la aplicación en el swarm manager. Para ello sabemos que el comando docker stack deploy despliega las aplicaciones, y tenemos un fichero de configuración docker-compose.yml . Tenemos nuestra maquina myvm1 activa. Nos situamos en el directorio donde reside el docker-compose.yml y ejecutamos

docker stack deploy -c docker-compose.yml getstartedlab

y nos contesta:

Creating network getstartedlab_webnet
Creating service getstartedlab_web

Veamos como se ejecuta:

docker stack ps getstartedlab

Y vemos que los servicios se distribuyen en ambas máquinas

ID                  NAME                  IMAGE                         NODE                DESIRED STATE       CURRENT STATE           ERROR               PORTS
lf3vepnhivp4        getstartedlab_web.1   ximodante/get-started:part2   myvm2               Running             Running 7 minutes ago                       
s0y522grwgyp        getstartedlab_web.2   ximodante/get-started:part2   myvm1               Running             Running 7 minutes ago                       
p6l9njwxhbrx        getstartedlab_web.3   ximodante/get-started:part2   myvm2               Running             Running 7 minutes ago                       
3phjbcb63xx8        getstartedlab_web.4   ximodante/get-started:part2   myvm1               Running             Running 7 minutes ago                       
o6um4bt8aoen        getstartedlab_web.5   ximodante/get-started:part2   myvm2               Running             Running 7 minutes ago                       

Vamos a acceder al cluster, ya sea por la dirección IP de myvm1 o myvm2, todas repiten las 5 instancias cíclicamente de hostname cuando refrescamos el navegador, demostrando la carga balanceada. Se dice pues que hay un "routing mesh"

Si ahora cambiamos el docker-compose.yml para cambiar el comportamiento del programa, al igual que hicimos en un post anterior hacemos

docker stack deploy -c docker-compose.yml getstartedlab

Podemos unir todas las máquinas que queramos con el docker swarn join, y a continuación hacer desplegarlas con docker-stack deploy anterior .

7. Parar el swarm y eliminarlo

Para parar el swarm ejecutamos:

docker stack rm getstartedlab

Para eliminar el swarm, tras haberlo parado en elpunto anterior:

Ejecutamos para el "worker":

docker-machine ssh myvm2 "docker swarm leave"

Ejecutamos para el "manager":

docker-machine ssh myvm1 "docker swarm leave --force"

Si queremos eliminar las variables de entorno de nuestra shell ejecutamos

eval $(docker-machine env -u)

Cosa que desconecta la shell de las máquinas virtuales creadas con "docker-machine create", y nos permite continuar trabajando con la misma shell, pero ahora usando los comandos "docker"

Si queremos rearrancar la máquinas docker ejecutamos:

docker-machine start <machine-name>

8. Cheat sheet

Ahí va un resumen:

docker-machine create --driver virtualbox myvm1 # Create a VM (Mac, Win7, Linux)
docker-machine create -d hyperv --hyperv-virtual-switch "myswitch" myvm1 # Win10
docker-machine env myvm1                # View basic information about your node
docker-machine ssh myvm1 "docker node ls"         # List the nodes in your swarm
docker-machine ssh myvm1 "docker node inspect <node ID>"        # Inspect a node
docker-machine ssh myvm1 "docker swarm join-token -q worker"   # View join token
docker-machine ssh myvm1   # Open an SSH session with the VM; type "exit" to end
docker node ls                # View nodes in swarm (while logged on to manager)
docker-machine ssh myvm2 "docker swarm leave"  # Make the worker leave the swarm
docker-machine ssh myvm1 "docker swarm leave -f" # Make master leave, kill swarm
docker-machine ls # list VMs, asterisk shows which VM this shell is talking to
docker-machine start myvm1            # Start a VM that is currently not running
docker-machine env myvm1      # show environment variables and command for myvm1
eval $(docker-machine env myvm1)         # Mac command to connect shell to myvm1
& "C:\Program Files\Docker\Docker\Resources\bin\docker-machine.exe" env myvm1 | Invoke-Expression   # Windows command to connect shell to myvm1
docker stack deploy -c <file> <app>  # Deploy an app; command shell must be set to talk to manager (myvm1), uses local Compose file
docker-machine scp docker-compose.yml myvm1:~ # Copy file to node's home dir (only required if you use ssh to connect to manager and deploy the app)
docker-machine ssh myvm1 "docker stack deploy -c <file> <app>"   # Deploy an app using ssh (you must have first copied the Compose file to myvm1)
eval $(docker-machine env -u)     # Disconnect shell from VMs, use native docker
docker-machine stop $(docker-machine ls -q)               # Stop all running VMs
docker-machine rm $(docker-machine ls -q) # Delete all VMs and their disk images

Docker (5) : Servicios

1. Introducción

Estamos siguiendo al pie de la letra docs-docker.

Recordamos los tres niveles

1. Stack (pila)
2. Services (servicios)
3. Containers (contenedores)

Nos vamos a centrar en el segundo nivel (services)

Entendemos como "service" cada una de las piezas de una aplicación distribuida. Los servicios son contenedores en producción. Si un servicio se "escala" (balancea), se le asigna mas recursos de máquina a aquellas contenedores ejecutando esa pieza de software.

Un servicio se escala mediante un fichero docker-compose.yml 

2. El fichero docker-compose.yml

Creamos el fichero docker-compose.yml en cualquier sitio y copiamos y pegamos estos datos:

version: "3"
services:
  web:
    # replace username/repo:tag with your name and image details
    image: ximodante/get-started:part2
    deploy:
      replicas: 5
      resources:
        limits:
          cpus: "0.1"
          memory: 50M
      restart_policy:
        condition: on-failure
    ports:
      - "80:80"
    networks:
      - webnet
networks:
  webnet:

Con ello:

1. Recogemos la imagen ximodante/get-started:part2 que guadamos en el post anterior
2. Ejecutamos 5 instancias de esa imagen como un servicio llamado web, limitando a cada una, un máximo del 10% de la CPU y 50MB de RAM.
3. Reiniciar el contenedor inmediatamente si falla.
4. Mapea el puerto 80 del host al puerto 80 de web.
5. Se le ordena al contenedor web, que comparta el puerto 80 a través de una red balanceada de cargas llamada webnet. Internamente los contenedores se publican a si mismos al puerto 80 de web, en un puerto efímero.
6. Se define la red webnet con los parametros por omisión (que es una red overlay (capa superior) con carga balanceada).

3. Ejecutar la nueva aplicación con carga balanceada

Para evitar el error; "this node is not a swarm manager", ejecutemos primero:

docker swarm init

Le damos a la aplicación el nombre: getstartedlab mediante el comando

docker stack deploy -c docker-compose.yml getstartedlab

Y nos contesta

Creating network getstartedlab_webnet
Creating service getstartedlab_web

Nuestra "stack" está ejecutando 5 instancias de "containers" de nuestra imagen despeglada en un host. Veamos la id del servicio

docker service ls

Y nos sale:

ID                  NAME                MODE                REPLICAS            IMAGE                         PORTS
vupp9jys8egi        getstartedlab_web   replicated          5/5                 ximodante/get-started:part2   *:80->80/tcp

Se puede ver  el servicio getstartedlab y sus 5 réplicas y su ID vupp9jys8egi

Un único contenedor ejecutándose en un servicio es una "task", que tienen IDs únicos que se incrementan numéricamente hasta el número de réplicas que hayamos definido. Para listar los "tasks"

docker service ps getstartedlab_web

Y nos sale

ID                  NAME                  IMAGE                         NODE                           DESIRED STATE       CURRENT STATE           ERROR               PORTS
pky3rokdocfa        getstartedlab_web.1   ximodante/get-started:part2   eduard-HP-ProDesk-600-G1-SFF   Running             Running 5 minutes ago                       
qdwszjdtqisk        getstartedlab_web.2   ximodante/get-started:part2   eduard-HP-ProDesk-600-G1-SFF   Running             Running 5 minutes ago                       
raamsw062xn5        getstartedlab_web.3   ximodante/get-started:part2   eduard-HP-ProDesk-600-G1-SFF   Running             Running 5 minutes ago                       
62hqh1yi00q5        getstartedlab_web.4   ximodante/get-started:part2   eduard-HP-ProDesk-600-G1-SFF   Running             Running 5 minutes ago                       
g8pdf2pk4f8j        getstartedlab_web.5   ximodante/get-started:part2   eduard-HP-ProDesk-600-G1-SFF   Running             Running 5 minutes ago  

Si pongo en hhtp://localhost en chrome no va, pero si en firefox (o ejecutando curl -4 hhtp://localhost . y si le damos varias, el hostname va cambiando, demostrando que se está blanceando la carga hasta mostrar 5 nombres distintos, correspondientes a los que nos muestra este comando

docker container ls -q

4. Escalar la aplicación

Se puede modificar el docker-compose.yml cambiando las réplicas y guardando el fichero. Si volvemos a ejecutar

docker stack deploy -c docker-compose.yml getstartedlab

Docker realiza una actualización "in-place" (en su sitio, en orden), sin necesidad de parar la "stack" o matar algún "container"

Si volvemos a ejecutar

docker container ls -q

veremos las nuevas instancias reconfiguradas

5. Parar la aplicación

Para desmantelar la aplicación:

docker stack rm getstartedlab

para desmontar el swarm

docker swarm leave --force

6. Resumen de comandos

docker stack ls                                            # List stacks or apps
docker stack deploy -c <composefile> <appname>  # Run the specified Compose file
docker service ls                 # List running services associated with an app
docker service ps <service>                  # List tasks associated with an app
docker inspect <task or container>                   # Inspect task or container
docker container ls -q                                      # List container IDs
docker stack rm <appname>                             # Tear down an application
docker swarm leave --force      # Take down a single node swarm from the manager

Docker (4): Contenedores

1. Introducción

Vamos a seguir la guia de docker.
Los niveles en docker són:

1. Stack (pila)
2. Services (servicios)
3. Containers (contenedores)

Como vemos el container es el nivel mas bajo y es el que vamos a ver en este post.

Tenemos que saber también estos conceptos:

• repository: Es una colección de "images" como un GitHub, pero el código ya esta compilado (built).
• registry: Es un conjunto de "repositories"

2. Crear un Dockerfile

Un "dockerfile" define lo va en el "environment" (entorno) en tu contenedor, como por ejemplo acceso a recursos como discos duros, network etc. Estos recursos se virtualizan y se aislan del resto del sistema. Por tanto se requiere mapear puertos para comunicarse con el mundo exterior. Pero te permite que la aplicación creada con este dockerfile se comporte de la misma manera donde quiera que la ejecutes.

Vamos a crear un dockerfile. Para ello:

1. Crear un directorio nuevo

mkdir mydocker

3. Crear un fichero llamado Dockerfile y copiar y pegar este contenido:

# Use an official Python runtime as a parent image
FROM python:2.7-slim

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
ADD . /app

# Install any needed packages specified in requirements.txt
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# Make port 80 available to the world outside this container
EXPOSE 80

# Define environment variable
ENV NAME World

# Run app.py when the container launches
CMD ["python", "app.py"]

Si te conectas mediante un proxy:

1. Averigua cuales son los host:puerto para http y https

2. Coloca estas líneas antes del comando pip. Siendo host:port los valores reales del proxy

# Set proxy server, replace host:port with values for your servers
ENV http_proxy host:port
ENV https_proxy host:port

Este dockerfile hace referencia a 2 ficheros que no hemos creado aún:

• app.py
• requirements.txt

Copiar este contenido a requirements.txt

Flask
Redis

Copiar este contenido a app.py

from flask import Flask
from redis import Redis, RedisError
import os
import socket

# Connect to Redis
redis = Redis(host="redis", db=0, socket_connect_timeout=2, socket_timeout=2)

app = Flask(__name__)

@app.route("/")
def hello():
    try:
        visits = redis.incr("counter")
    except RedisError:
        visits = "<i>cannot connect to Redis, counter disabled</i>"

    html = "<h3>Hello {name}!</h3>" \
           "<b>Hostname:</b> {hostname}<br/>" \
           "<b>Visits:</b> {visits}"
    return html.format(name=os.getenv("NAME", "world"), hostname=socket.gethostname(), visits=visits)

if __name__ == "__main__":
    app.run(host='0.0.0.0', port=80)

El fichero requirements.txt nos informa de los requisitos, y la instalación se hace mediante el comando de Dockerfile pip install -r requirements.txt 

3. Hacer un build de la aplicación

Verificar que estamos en nuestro directorio de prueba mydocker,

Para crear la "image" y darle el nombre "friendlyhello" por ejemplo, ejecutar el comando (sin olvidar el "punto" final

docker build -t friendlyhello .

Para ver si se ha creado

docker image ls

Y nos sale

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
friendlyhello       latest              0b0e63dce66e        19 seconds ago      148MB
python              2.7-slim            52ad41c7aea4        13 days ago         139MB
hello-world         latest              f2a91732366c        3 months ago        1.85kB

4. Correr la aplicación (run)

Vamos a correr la aplicación pero:

• Mapeamos el puerto 80 del contenedor al puerto 4000 de nuestra máquina
• Para ello usamos la opción -p 

docker run -p 4000:80 friendlyhello

Nos contesta:
* Running on http://0.0.0.0:80/ (Press CTRL+C to quit)

Pero en realidad debe correr en el puerto 4000 de nuestra máquina

Como Redis no está corriendo, ya que solo hemos instalado Python y no Redis, nos va a dar un error cuando intentemos acceder a ella.

Tambien podemos ejecutar esta orden para ver el mismo contenido

curl http://localhost:4000

Y nos devuelve:

<h3>Hello World!</h3><b>Hostname:</b> 1d56760bd269<br/><b>Visits:</b> <i>cannot connect to Redis, counter disabled</i>

Para terminar la aplicación basta con hacer CTRL+C

También se puede ejecuta la aplicación en "background" (desatendida)  en modo "detached"

Para ver los "containers" en marcha

docker container ls

Y sale

CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS              PORTS                  NAMES
f930900febff        friendlyhello       "python app.py"     About a minute ago   Up About a minute   0.0.0.0:4000->80/tcp   wizardly_albattani

Y este container ID  debe coincidir con el Hostname que aprece tras refrescar el navegador

Para parar la ejecución, anotamos el container ID y ejecutamos

docker container stop f930900febff

5. Compartir la imagen

Vamos a obtener una cuenta "Docker account", firmando en cloud.docker.com

Anotamos usuario y contraseña y entramos

docker login

Nos pide usuario y contraseña

Para asociar una "image" local con un "repository" en un "register" es

username/repository:tag

Siendo tag opcional, pero casi necesaria para saber la versión. Dar valores que den cierto significado como "get-started:part2". De esta forma se colooca la "image" en el "repository" "get-started" y la "tag" es "part2"

por ejemplo ejecutamos

docker tag friendlyhello ximodante/get-started:part2

 y para ver las imágenes

docker image ls

Y sale

REPOSITORY              TAG                 IMAGE ID            CREATED             SIZE
friendlyhello           latest              0b0e63dce66e        About an hour ago   148MB
ximodante/get-started   part2               0b0e63dce66e        About an hour ago   148MB
python                  2.7-slim            52ad41c7aea4        13 days ago         139MB
hello-world             latest              f2a91732366c        3 months ago        1.85kB

Ahora queda:

6. Publicar la imagen

Subir la imagen etiquetada al "repository" (docker push username/repository:tag)

docker push ximodante/get-started:part2

Y sale:

The push refers to repository [docker.io/ximodante/get-started]
f85a5baf41ba: Pushed 
728d44a64a71: Pushed 
1db758961ede: Pushed 
03cd3fb86dd2: Mounted from library/python 
630d02da980e: Mounted from library/python 
b2f046b20847: Mounted from library/python 
cf051be4e149: Mounted from library/python 
part2: digest: sha256:0e691ecddf8589cce361d0db30f37f9e6ffa24f2a14dfa3f12a0d9d6c48439dd size: 1787

Si entramos en Docker Hub y nos identificamos sale esta pantalla con nuestra imagen

A partir de ahora, en cualquier máquina que tenga instalado docker, podemos ejecutar esta "image"

docker run -p 4000:80 ximodante/get-started:part2

Si la imagen no está disponible en el contenedor local, Docker la recoge desde el repositorio

No importa desde que máquina ejecutes el docker run. Se recoge la "image" juto con todas las dependencias de requirements.txt y ejecuta el código, y no necesitas instalar nada, docker lo hace por ti

Docker (3): Configurar el entorno

1. Introducción. Conceptos básicos. Container, image, VM

Vamos a seguir la guía de docker.

Docker permite desarrollar, desplegar y ejecutar aplicaciones mediante contenedores (containers).

Un "container" es una instancia (en ejecución) de una "image".

Una "image" es un paquete ejecutable que incluye todo lo suficiente para correr una aplicación (código, , runtime, librerías, variables de entorno y ficheros de configuración)

Se pueden ver los "containers" que se están ejecutando mediante el comando

docker ps

docker ps

Un "container" corre nativamente en Linux y comparte el kernel del host con otros "containers".  Se ejecuta como un proceso, utilizando la memoria eficientemente de forma ligera (lightweight).

En cambio una máquina virtual (VM), ejecuta un sistema operativo completo como invitado, accediendo a los recursos de manera virtual ca través de un "hypervisor". Y por tanto consume muchos mas recursos que una simple aplicación requiere.

2. Configurar entorno

Verificar la versión

docker --version

Sale:

Docker version 17.12.1-ce, build 7390fc6

Para listar la imagen "hello-world" :

docker image ls

Y sale

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              f2a91732366c        3 months ago        1.85kB

Copiamos la guia resumen de instrucciones de docker:

## Lista los comandos Docker CLI 
docker
docker container --help

## Muestra la versión Docker y otra información
docker --version
docker version
docker info

## Ejecuta una Docker image
docker run hello-world

## Lista las Docker images
docker image ls

## Lista los Docker containers (en ejecución, todos, todos en quiet mode)
docker container ls
docker container ls --all
docker container ls -a -q

Conckuyendo: Docker permite la definición de nuevos "ejecutables" "ligeros" en contraposición a las pesadas VM.

Docker: (2) Post Instalación para Ubuntu 16.04

1. Introducción

Parece ser que es conveniente realizar ciertos pasos después de instalar Docker en Ubuntu 16.04:

1. Disponer de un usuario que no sea "root"
2. Configurar Docker para que se ejecute al arrancar el sistema
3. Usar diferentes "storages engines".
4. Configurar el daemon para ver que conexiones a escuchar

2. Definir usuarios especificos de Docker

1. Crear el grupo "docker" (seguramente ya exista)

sudo groupadd docker

2. Añadir nuestro usuario al grupo docker

sudo usermod -aG docker $USER

3. Salir de la sesión de este usuario y volver a entrar y ejecutar "docker" sin "sudo"

docker run hello-world

y vemos que funciona.

3. Configurar Docker en el arranque (boot)

Para ver si está configurado para el aranque se teclea (Ubuntu 16.04)

service --status-all

Si no apareciera, se puede añadir o quitar con estos comandos respectivamente

sudo systemctl enable docker

sudo systemctl disable docker

Si queremos arrancar el daemon manualmente se procede:

dockerd

Que permite varias opciones de configuración


Dado el caracter introductorio de este manual y mi lamentable nivel de Docker, de momento me paro aquí.

Docker: (1) Instalación para Ubuntu 16.04

1. Introducción

Como voy a empezar con Docker, empiezo por lo fácil que es la Comunity Edition
Voy a seguir las instrucciones de Docker docs, para ello hay que seguir estos pasos:

2. Configurar el repositorio

Para ello voy ejecutando estos comandos.

1.  sudo apt-get update
2.  sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
3.  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
4.  sudo apt-key fingerprint 0EBFCD88
5.  sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

El cuarto comando es para verificar que el fingerprint es:

9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88

3. Instalar Docker

Para ello voy ejecutando estos comandos.

1.  sudo apt-get update
2.  sudo apt-get install docker-ce

3.  sudo docker run hello-world

Según dicen las instrucciones ya se habrá iniciado el daemon de docker tras el segundo comando

El tercer comando es para verificar que funciona, y nos devuelve:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
ca4f61b1923c: Pull complete 
Digest: sha256:083de497cff944f969d8499ab94f07134c50bcf5e6b9559b27182d3fa80ce3f7
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://cloud.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/

Puede ocurrir que por temas de permisos, se queje si no ejecutamos docker con "sudo", para ello hay que cambiar los permisos al directorio de docker así

sudo chmod 666 /var/run/docker.sock

4. Desinstalar Docker

Si por algun motivo quisiéramos desinstalarlo se procedería así:

1.  sudo apt-get purge docker-ce
2.  sudo rm -rf /var/lib/docker

Ubuntu problemas al formatear un pen USB

Tengo un USB de 64GB que guarde un ISO de Ubuntu 16 de autoarranque y no había manera de formatearlo.

Para ello seguí las instrucciones de Ask Ubuntu

Tras buscar "Disc" me aparece que el USB tiene 3 particiones:

1. /dev/sdi1
2. /dev/sdi2
3. /dev/sdi

No hay manera de eliminarlas con este programa.

Para ello he entrado en una consola y he tecleado:

1. Acceder como superusuario

sudo su

2. Desmontar los sistemas de ficheros. (Puede que algunos esten ya desmontados y de algún error, pero no importa, hay que asegurarse que esten desmontados)

umount /dev/sdi1
umount /dev/sdi2
umount /dev/sdi

3. Montar todo el dispositivo

mkfs.vfat /dev/sdi

4. Modificar el pen ( En este caso se e da el nombre "INTENSO" al PEN) Y se le da formato rápido a FAT32.

mkfs.vfat -n 'INTENSO' -I /dev/sdi

Y a funcionar