una imagen es el empaquetador que contiene las dependencias el codigo y es lo que se comparte

un container son capas tras capas de imagenes

existen tres tipos de virtualizaciones en las VM virtualmachine
1.- para virtualizacion
en la paravirtualizacion intenta entregar la mayor cantidad de acceso del sistema anfitrion de su hardware a los cientes en el contenedor

2.- virtualizacion parcial
donde algunos componentes del hardware se virtualizan para en sistema operativo cliente

3.- virtualizacion completa:
donde absolutamente todos los componentes o hardware que esta utilizando el sistema operativo cliente son virtualizados de esta manera los sistemas operativos cliente no acceden en los absoluto al hardware

para todos los casos anteriores docker va a ser absolutamente superior y va a utilizar el kernel del sistema opetativo anfitrion y esto se traduce en rendimiento, los contenedores de docker parten casi que instantaneamente, obteniendo un rendimiento muy superior a todas las alternativas mencionadas anteriormente fin de la teoria


docker desktop es una maquina virtual se encuentra optimizada
corre linux
ejecuta containers
permite acceder al sistema de archivos y tambien a la red(interna y externa)

docker desktop no es una unica herramienta viene con otras herramientas que nos sirven para trabajar con nuestras imagenes y tambien con nuestros containers dentro de estas herramientes tenemos 

docker compose, docker cli ademas de otras herramientas

puede correr de manera nativa en windows con la herramienta WSL2(windows subsystem for linux)


existe una alternativa de instalacion para windows,linux y mac

para windows una sola opcion solamente es descargarlo y presionar siguiente siguiente siguente y listo

para mac existen dos alternatinas pulsar la de la derecha en la pagina web de docker

para linux docker ya tiene paquetes de instalacion pre compilados dependiendo de la version de linux que estes utilizando utiliza la alternativa que mas te funcione

que es dockerHUB: es un repositorio de imagenes o contenedores disponibles para comenzar a trabajar oficiales para utilizar

proceso para instalarlo
* docker images : devuelve un listado completo de todas las imagenes que hallamos descargado en nuestra maquina
donde repositorio te muestra el nombre de la imagen que se halla descargado, cada repositorio puede tener una o mas etiquetas con la version de la imagen

para descargar una imagen tenemos dos alternativas con el siguiente comando
1.-descargar la version que nosotros queremos
2.- no especificar nada esto va a descargar la ultima version de la imagen que queramos descargar
ejemplo:
* docker pull node

este comando te descargara cada una de las capas que componen la imagen de manera que si tenemos que descargar otra imagen y sus capas ya han sido descargadas por otro imagen las capas ya descargadas anteriormente ya no se volveran a descargar de esta manera de aprovecha espacio y tambien las distintas imagenes para optimizar un poco mas el espacio que estas van a utilizar en el disco duro

para descargar una version especifica de una imagen
* docker pull node:18

la imagen id es la misma que las otras versiones relativamente similares lo que cambia es la etiqueta de la version

para descargar la imagende mysql 
en mac se debe colocar 
* docker pull --platform linux/x86_64 mysql

normal es 

* docker pull mysql

tambien podemos indicar una version

* docker pull mysql:numeroversion

para eliminar una imagen en ejecucion el comando es

* docker image rm nombredelaimagen

la imagen de docker pull no necesita tantas configuraciones

Despues de descargar una imagen se procede a crear un contenedor

* docker create mongo (forma corta)

* docker container create mongo (forma larga) 

nos devuelve un id del contenedor (este id nos sirve para crear un contenedor)
el comando para ejecutar un contenedor es:

* docker start idContenedor (donde idcontenedor es el codigo id largo del contenedor) esto nos devuelve el id del contenedor nuevamente

* docker ps : este comando es como docker iamges pero se usa para ver los contenedores creados, cuando se crea un contenedor se le agrega un nombre de manera arbitraria al contenedor y ese nombre se puede usar en lugar del idcortocontenedor para eliminar el contenedor

* docker ps -a para ver todos los contenedores incluso los que no se estan ejecutando

para detener el contenedor se debe usar el comando

* docker stop idcortocontenedor

para asignar un nombre a un contenedor:

* docker create --name nombreContenedor esto nos devuelve el idlargo del contenedor indicando que ya se ha creado el contenedor

y como ya le hemos asignado un nombre al contenedor podemos iniciarlo con:

* Docker start nombreContenedorAsignado

para poder guardar datos dentro de un contenedor se debe mapear el puerto local al puerto del contenedor:

* docker create -p27017:27017 --name nombreContenedor nombreImagenBase donde lo que esta antes del : es el puerto de la maquina nuestra la maquina local y lo que esta despues del : es el puerto interno del contenedor, siempre asignale un puerto a cada contenedor creado por que si dejas que docker asigne un puerto los va a asignar por encima del puerto 50mil

con el comando 
docker logs nombreContenedor  puedes ver todos los logs que este nos muestra y tambien puedes verlo con

* docker logs --follow nombreContenedor la diferencia es que este se queda escuchando y mostrando los logs en tiempo real

el comando docker run hace tres cosas 
1.-descarga la imagen
2.-crea el contenedor
3.-inicia el contenedor

* ejemplo docker run mongo
docker run mongo

los siguientes dos comandos devulven el id del contenedor creado
docker run -d mongo este nos asigna un nombre arbitrariamente por docker
docker run --name nombreContenedor -p27017:27017 -d imagenbase este comando nos permite crear un contenedor mas personalizado

luego para ver el contenedor usa el comando 
* docker ps

configuracion del archivo dockerfile
tomar una aplicacion de docker un meterla dentro de un container
el archivo dockerfile no puede tener otro nombre se tiene que llamar dockerfile, este archivo se utiliza para que nosotros podamos construir nuestros containers, aqui nosotros vamos a escribir las instrucciones que necesita nuestro contenedor para poder crearse,m todas las imagenes que nosotros creemos siempre se tienen que basar en alguna otra imagen

ejemplo
* FROM node:etiquetaversion

RUN mkdir -p /home/app --esto es donde vamos a meter el codigo fuente de nuestra aplicacion, esta ruta no es una ruta fisita en nuestra maquina sino que es una ruta en el contenedor 

COPY . /home/app

EXPOSE 3000 ruta donde se va a ejecutar la aplicacion

CMD ["node","/home/app/index.js"]

ahora vamos a aprender a crear redes en docker

* docker ls : lista todas las redes existentes

* docker network create mired : este comando creara una nueva red dentro de docker este nos devolvera el id de la red creada

* docker network rm mired este comando elimina la red creada anteriormente

el siguiente comando recibe dos argumentos (nombreDadoPorMI,rutanodenosencontramos ) y se utiliza para construir contenedores en base a un archivo dockerfile

* docker build -t miapp:etiquetaversiondadapormi .

*docker create -P27017:27017 --name monguito --network mired -e MONGO_INITDB_ROOT_USERNAME=nico -e MONGO_INIT_DB_ROOT_PASSWORD=password mongo

ahora para colocar el contenedor de la aplicacion que nosotros acabamos de colocar dentro de una imagen

*docker create -p3000 --name chanchito --network mired miapp:1

*luego escribir docker ps -a

luego de hacer esto debemos arrancar los dos contenedores que creamos y que estan dentro de una misma red
sudo docker start monguito
sudo docker start chanchito

resumen de pasos para poder crear contenedores y tambien conectarlos
descargar la imagen
crear una red
crear el contenedor
	asignar puertos 
    asignar un nombre
    variables de entorno
    especificar la red
    indicar la imagen:consuetiqueta
todo esto por cada contenedor

para automatizar todo los pasos anteriores existe la herramienta docker compose
para esto debemos crear y editar un archivo con extension.yml

la estructura de este archivo es la siguiente
version:"3.9"
services:
	chanchito:
		build: .
        ports:
			-"3000:3000"
		links:
			-monguito
	monguito:
		imagen:mongo
        	ports:"27017:27017"
		environment:
			- MONGO_INITDB_ROOT_USERNAME=nico
			- MONGO_INITDB_ROOT_PASSWORD=password

ahora para ejecutar un archivo docker yml o docker compose se utiliza el siguiente comando:
docker compose up

luego verificas las imagenes creadadas con 

*docker images

con el comando 
docker compose down que es lo contrario de docker compose up, para eliminartodo lo que se creo anteriormente con docker compose up

para trabajar con volumenes vamos al final del archivo compose 
version:"3.9"
services:
	chanchito:
		build: .
        ports:
			-"3000:3000"
		links:
			-monguito
	monguito:
		imagen:mongo
        	ports:"27017:27017"
		environment:
			- MONGO_INITDB_ROOT_USERNAME=nico
			- MONGO_INITDB_ROOT_PASSWORD=password
		volumes:
			-mongo-data:/data/db
            # mysql -> var/lib/mysql
            # postgres -> var/lib/postgresql/data
volumes:
	mongo_data:

para crear multiples ambientes de desarrollo mientras estamos trabajando con docker
primero debemos crear un archivo con extension.dev ejemplo dockerfile.yml ya que el archivo que teniamos anterior mente quizas queramos usarlo para produccion ejemplo dockerfile.dev la estructura este este archivo es parecida al archivo dockerfile anterior con algunas diferencias

FROM node:18

RUN npm i -g nodemon
RUN mkdir -p /home/app

WORKDIR /home/app

EXPOSE 3000

CMD ["nodemon","index.js"]

ademas de este archivo demos crear un archivo compose para desarrollo tambien al cual llamaremos docker-compose-dev.yml con la siguiente estructura
version:"3.9"
services:
	chanchito:
		build: 
        context: .
        dockerfile:dockerfile.dev
        ports:
			-"3000:3000"
		links:
			-monguito
		volumes: 
			- .:/home/app
	monguito:
		imagen:mongo
        	ports:"27017:27017"
		environment:
			- MONGO_INITDB_ROOT_USERNAME=nico
			- MONGO_INITDB_ROOT_PASSWORD=password
		volumes:
			-mongo-data:/data/db
            # mysql -> var/lib/mysql
            # postgres -> var/lib/postgresql/data
volumes:
	mongo_data:

para provar el archivo que acabamos de construir utilizamos el siguiente comando, un archivo docker compose completamente customisado que no sea docker-compose.yml

docker compose -f docker-compose-dev.yml up