Diferencia entre revisiones de «Usuario:ManuelRomero/ProgramacionWeb/Docker/contenedorVsImagen»

De WikiEducator
Saltar a: navegación, buscar
Línea 141: Línea 141:
 
<div class="slide">
 
<div class="slide">
 
<!--8------------------------------------------------------>
 
<!--8------------------------------------------------------>
−
;Terminal en el contenedor: interactivamente:  <span class=resaltado>docker run -ti ..../span>
+
;Terminal en el contenedor: interactivamente:  <span class=resaltado>docker run -ti ....</span>
 
*Con el contenedor creado previamente podemos ejectura acciones, pero si queremos interactuar con él, debemos de permitir abrir un terminal y establecer interacción
 
*Con el contenedor creado previamente podemos ejectura acciones, pero si queremos interactuar con él, debemos de permitir abrir un terminal y establecer interacción
 
*Para ello hemos de aportar el parámetro '''''-t''''' para poder abrir terminal y '''''-i''''' para interactuar
 
*Para ello hemos de aportar el parámetro '''''-t''''' para poder abrir terminal y '''''-i''''' para interactuar
Línea 148: Línea 148:
 
</source>
 
</source>
 
</div>
 
</div>
 +
 +
<!--9------------------------------------------------------>
 +
 +
<div class="slide">
 +
*Ahora para abrir un terminal, ejecutamos el comando bash
 +
<source lang=bash>
 +
docker run -ti --name web ubuntu:latest
 +
</source>
 +
</div>
 +
 +
 +
<!--10------------------------------------------------------>
 +
 +
<div class="slide">
 +
====Estableciendo un forward o mapeando puertos====
 +
;Situación:
 +
*Ahora tenemos un docker. Podremos acceder a él a través de la ip, ya que se ha creado una red interna entre el anfitrión y el contenedor.
 +
*La configuración de la red, se puede establecer, en linux, por defecto suele empezar con la red '''''172.17.0.0''''', por lo que se crea la siguiente situación
 +
[[Archivo:Docker_forward_1.png|200px|center]]
 +
</div>
 +
 +
 +
<!--11------------------------------------------------------>
 +
 +
<div class="slide">
 +
;Estableciendo un forward o mapeando puertos
 +
*Si en el docker tenemos instalado un servidor web, como va a ser nuestro caso, y queremos que atienda nuestras solicitudes, sería fácil acceder a él a través de la ip.
 +
*Pero se presenta un problema en sistema windows y si queremos acceder a nuestro docker, desde otra máquina, ya que la red es interna, y en windows no se permite acceder al docker por ip.
 +
*La solución es mapear o realizar un fordward de puertos, de modo que estableceremos un puerto en nuestro anfitrión (el valor que queramos asignar por encima del 1024) que mapearemos al puerto 80 o 443 de nuestro docker, de manera que todas las solicitudes que reciba nuestro anfitrión se redirigan al servidor web del docker.
 +
*Podemos ver el escenario en la imagen siguiente:
 +
[[Archivo:docker_forward_2.png|400px|center]]
 +
</div>
 +
 +
 +
<!--12------------------------------------------------------>
 +
 +
<div class="slide">
 +
;Estableciendo un forward o mapeando puertos <span class=resaltado>docker run -p puerto_anfitrion:puerto:docker ...</span>
 +
<source lang=php>
 +
#Primero borramos el docker que teníamos
 +
docker rm web
 +
#Lo volvemos a crear, mapeando puertos
 +
docker run -ti -p 8080:80  --name web ubuntu:latest
 +
</source>
 +
</div>
 +
 +
<!--13------------------------------------------------------>
 +
 +
<div class="slide">
 +
====Compartiendo carpetas entre anfitrión y docker====
 +
;Situación:
 +
*Ahora ocurre que el apache de docker va a ejecutar recursos que vamos a debemos tener almacenados en el docker
 +
*Esos recursos van a ser programas de php que escribiremos
 +
*Usaremos un EDI, por ejemplo phpstorm, para crear dichos recursos, pero el EDI, no lo vamos a ejectuar dentro del docker, sino en nuestra máquina anfitriona
 +
[[Archivo:docker_compartir_carpeta_1.png|250px|center]]
 +
</div>
 +
 +
 +
<!--14------------------------------------------------------>
 +
 +
<div class="slide">
 +
;Compartiendo carpetas entre anfitrión y docker
 +
*Vamos a crear una carpeta compartida entre anfitrión y contenedor
 +
*De forma que todo lo que haya en esa carpeta y creemos en el anfitrión, estará disponible en el contenedor
 +
*La acción es bidireccional, todo lo que haya y creemos en el contenedor, estará disponible en el anfitrión
 +
[[Archivo:docker_compartir_carpeta_2.png|400px|center]]
 +
</div>
 +
 +
 +
<!--15------------------------------------------------------>
 +
 +
<div class="slide">
 +
;Estableciendo un forward o mapeando puertos <span class=resaltado>docker run -v dir/anfitrion:/dir/contenedor ...</span>
 +
<source lang=php>
 +
#Primero borramos el docker que teníamos
 +
docker rm web
 +
#Lo volvemos a crear, mapeando puertos
 +
docker run -ti -p 8080:80  -v /home/user/docker:/var/www/html --name web ubuntu:latest</span>
 +
</source>
 +
{{nota|
 +
*Se creará un directorio en local según especificquemos
 +
*Si trabajamos en linux, el directorio lo habrá creado docker, y por lo tanto será propiedad de root (hay que cambiar permisos)
 +
*En windows no existe esta circunstancia
 +
*Ahora ya podemos crear los proyectos con nuestro edi, y el apache del docker los encontrará para ejecutarlos
 +
}}
 +
</div>
 +
 +
<!--16------------------------------------------------------>
 +
 +
<div class="slide">
 +
*Vamos a instalar en el contenedor los paquetes que necesito para nuestra arquitectura web:
 +
;Apache
 +
;PHP
 +
;xdebug
 +
*Para ello vamos a la sección de instalación del sistem y realizamos las instalaciones correspondientes
 +
<source lang=bash>
 +
docker run -ti --name web ubuntu:latest
 +
</source>
 +
</div>
 +
 +
 +
 +
 +
<!--
 +
3.-El nombre del contenedor lop doy explícito  '''''-name idioma'''''<br />
 +
4.-La crearemos con un volumen mapeando el directorio /var/www/html del contenedor con /var/www/idioma de mi anfitrión '''''-v /var/www/html:/var/www'''''<br />
 +
 +
</div>
 +
<div class="slide">
 +
:1.- comando '''''run''''':ej. Descargar una imagen llamada '''''ubuntu:latest'''''
 +
 +
:2.-#fichero '''''yml''''' con '''''docker-composer '''''.
 +
docker-composer up
 +
</div>
 +
<div class="slide">
 +
 +
====Obtener o Crear una Imagen====
 +
*Para obtener una imagen, la podemos descargar de la nube o bien construirla a partir de otra imagen o de un contenedor:
 +
# '''''pull''''' para abtener una imagel
 +
# Fichero '''''Dockerfile'''' con el comando '''''build''''' para construir a partir de otra imagen
 +
<source lang=bash>
 +
docker build .
 +
</source>
 +
# Comando '''''commit''''' a partir de un contenedor con todo lo que tenga instalado
 +
<source lang=bash>
 +
docker commit contenedor:v1 - .
 +
</source>
 +
 +
# Comando '''''import''''' a partir de un fichero '''tar''' previamente creado de un contenedor con el comando '''''export''''',
 +
<source lang=bash>
 +
docker export contenedor.tar
 +
</source>
 +
 +
</div>
 +
<div class="slide">
 +
[[Archivo:imagen_contenedor_2.png]]
 +
</div>
 +
<div class="slide">
 +
 +
 +
</div>
 +
 +
*{{Docker/Registro}}
 +
 +
===Acciones concretas===
 +
;Crear un contenedor a partir de una imagen del repositorio<br />
 +
1.-A partir de la imagen '''''ubuntu:latest'''''<br />
 +
2.-El contenedor que se quede activo disponible interactivamente '''''-ti'''''<br />
 +
3.-El nombre del contenedor lop doy explícito  '''''-name idioma'''''<br />
 +
4.-La crearemos con un volumen mapeando el directorio /var/www/html del contenedor con /var/www/idioma de mi anfitrión '''''-v /var/www/html:/var/www'''''<br />
 +
 +
{{MRM_Puntos clave|Title=Crear un contenedor|
 +
;Se puede crear de diferentes formas
 +
*'''''run'''''. Con este comando es la forma mas básica de crearlo
 +
*'''''Dockerfile''''': Se crea el fichero y con el comando built podemos construir un contenedor a partir de la especificación del fichero
 +
*'''''docker.compose.yml''''',  un fichero que me va a permitir crear/levantar varios contenedores especificando todas mis necesidades
 +
}}
 +
<source lang="bash">
 +
  sudo docker run --name idioma -v /var/www/idioma:/var/www/html -ti ubuntu:latest
 +
</source>
 +
*Verificamos que se han creado los dos directoris (tanto el anfitrión (idioma) como en el contenedor (www/html)
 +
 +
;En el contenedor
 +
[[Archivo:mapeo_dir_docker1.png]]
 +
;En el anfitrión
 +
[[Archivo:mapeo_dir_anfitrion1.png]]
 +
*Mira los permisos (lo ha creado docker,  docker siempre actúa como root)
 +
*los modificamos
 +
<source lang=bash>
 +
sudo apt-get chown manuel:www-data /var/www/idioma
 +
</source>
 +
 +
*para ver más opciones disponibles
 +
<source lang=bash>
 +
sudo docker help run
 +
</source>
 +
;Ver los contenedores del sistema
 +
<source lang="bash">
 +
  sudo docker ps -a
 +
</source>
 +
;Ver los las imágenes  del sistema
 +
<source lang="bash">
 +
sudo docker images
 +
</source>
 +
 +
;Modificar un contenedor
 +
*Una vez abierto el contenedor podemos proceder a instalar cosas.
 +
*Para la práctica necesitamos instalar una serie de paquetes (si necesitamos más los ponemos)
 +
{{MRM_Clave|Title=Paquetes a instalar|
 +
;apache y php
 +
apt-get install apache2 php libapache2-mod-php
 +
;gettext (luego comentaremos)
 +
}}
 +
{{MRM_Clave|Title=Paquetes a instalar|
 +
;net-tools y vim
 +
*Estos paquetes los instalo para poder ver la ip y como editor
 +
apt-get install net-tools vim
 +
}}
 +
{{Tip|Si tenemos dudas podemos mirar el apartado de instalación del primer tema del curso, también si queremos instalar java, xdebug u otros paquetes}}
 +
;Crear una imagen en local a partir de un contenedor
 +
{{MRM_Puntos clave|Title=Crear una imagen|
 +
;commit}}
 +
*Igual que en git,
 +
docker [opciones] nombre_container [nombre_img:tag]
 +
<source lang="bash">
 +
docker commit -m "Con webservice" -a "Manuel Romero<dir@dom.com>" idioma img_idioma:v1
 +
</source>
 +
[[Imagen:commit_img1.png]]<br />
 +
*Y vemos cómo se ha creado
 +
[[Imagen:img_creada1.png]]<br />
 +
 +
 +
=====Arrancar un contenedor =====
 +
 +
*Una vez cerrado el contenedor (no parado), éste sigue estando disponible
 +
*Una vez que cerremos el contenedor, mientras no lo destruyamos, podremos disponer de él, aunque apaguemos la máquina, digamos que se queda pausado
 +
;Crear una imagen en local a partir de un contenedor
 +
{{MRM_Puntos clave|Title=Arrancar un contenedor|
 +
;start
 +
;exec
 +
}}
 +
 +
*Para usarlo hay que realizar dos acciones
 +
<source lang=bash>
 +
~ ➭  docker start  dwes
 +
dwes
 +
~ ➭  docker exec -ti dwes /bin/bash
 +
root@496b9ba15066:/#
 +
</source>
 +
 +
 +
 +
:Crear un contenedor a partir de una imagen en local
 +
*Con el comando run, pero especificando la imagen local
 +
:Crear un contenedor con un volumen lógico a partir de una imagen en local
 +
*Para ello usamos el parámetro -v
 +
<source lang=bash>
 +
docker run --name nombre_contenedor_nuevo -v /var/www/iternova:/var/www -dti nombre_imagen
 +
</source>
 +
 +
====Realziar una copia de un contenedor en un fichero====
 +
*Podemos hacerlo de diferentes maneras. una sencilla es usar el comando export / import
 +
[[archivo:export_docker.png]]
 +
[[archivo:import_docker.png]]
 +
====Exportar e Importar====
 +
;Exportar
 +
*Se exportará un contenedor a una imagen y se almacenará en un fichero tar.
 +
*De esta forma la imagen contendrá todos los servicios instalados en el contenedor.
 +
*Recordad que los contendios de los volúmenes no forman parte del contenedor, aunque se pueda acceder desde ellos. Físicamente estarán en el directorio especificado en el volumen de la máquina anfitriona.
 +
{{MRM_Actividad|Title=Pasos a seguir para exportar una imagen|
 +
1.- Paramos la imagen
 +
<source lang=bash>
 +
docker stop nombre_contendor
 +
</source>
 +
2.- Exportar la imagen
 +
<source lang=bash>
 +
docker export nombre_contendor -0 nombre.tar
 +
</source>
 +
*Esto nos creará un fichero con nombre '''''nombre.tar''''' que contendrá la imagen
 +
}}
 +
;Importar
 +
*Se importará una imagen a partir de un fichero tar que la contiene
 +
*Una vez importada la imagen podremos crear un contenedor con los parámetros que consideremos.
 +
*El contenedor creado, contendrá todos los servicios que tenía el contenedor  a partir del cual se creó la imagen en el fichero tar (contenedor que exportamos previamente).
 +
{{MRM_Actividad|Title=Pasos a seguir para importar una imagen|
 +
2.- Importar la imagen
 +
<source lang=bash>
 +
docker import nombre.tar nombre_imagen:tag
 +
</source>
 +
*Esto nos creará una imagen que la llamamos como consideremos a partir del fichero nombre.tar
 +
*Ahora podemos comprobar que tenemos la imagen
 +
<source lang=bash>
 +
docker images
 +
</source>
 +
*Ahora podemos crear un contendor, por ejemplo siguiendo con la clase
 +
<source lang=bash>
 +
docker run --name nombre_contenedor_que_creo -v c:\Users\web:/var/www/html -p 80:80 -dti nombre_imagen:tag
 +
</source>
 +
}}
 +
 +
 +
*{{Docker/comandosImágenes}}
 +
*{{Docker/comandosContenedor}}
 +
*{{Docker/volumenesYCopiarContenedorHost}}
 +
{{MRM_Web|Title=Docker composer|
 +
https://medium.com/@carlos.compains/creando-un-entorno-de-desarrollo-con-docker-a56790af6271
 +
}}
 +
 +
===Dockerfile===
 +
<br />
 +
{{MRM_Web|Title=Referencia de DockerFile|
 +
https://docs.docker.com/engine/reference/builder
 +
}}
 +
*Hasta ahora hemos creado un '''''contenedor''''' a partir de una '''''imagen''''' usando el comando '''''run'''''
 +
*Una vez que tenemos el contenedor le agregamos los servicios que necesitamos
 +
*Para no perder el trabajo, de ese contenedor creamos una imagen y ya lo tenemos disponible para crear nuevos contenedores con todos los servicios instalados
 +
 +
 +
 +
*Es un '''''fichero de texto''''', que me permite crear '''''una imagen''''' a partir de otra, y añadir una serie de comandos para instalar a esa imagen, aplicaciones, servicios, librerías diversas con el objetivo de construirme una imagen para lanzar un contenedor personalizado a mis necesidades.
 +
*Una vez creado el fichero, lo ejecutaremos y crearemos la imagen con el comando '''''buld'''''
 +
*Si el fichero está en el directorio actual, lo ejecutaremos con el comando '''''punto'''''
 +
*Para ejecutar la máquina ejecutamos
 +
<source lang=bash>
 +
docker build .
 +
</source>
 +
;Estructura del fichero
 +
<source lang=bash>
 +
# comentarios
 +
INSTRUCCIONES argumentos
 +
</source>
 +
En un fichero dockerfile tendremos dos tipos de líneas
 +
#comentarios (líneas que empiezan por '''''#''''')
 +
#Sentencias líneas que tiene una instrucción con una serie de argumentos para ejecutarlas
 +
##Por se recomienda poner las instrucciones en mayúsculas
 +
====Instrucciones====
 +
;FROM
 +
FROM <imagen>
 +
FROM <imagen>:<tag>
 +
FROM <imagen>@<digest>
 +
*
 +
*Es la primera instrucción
 +
*Especifica la imagen base de la que parte la instalación que queremos hacer
 +
* En esta página puedes encontrar imágenes base de las cuales partir (hay miles)
 +
*En el FROM se puede especificar de forma opción el tag o digest (sirve para especificar la imagen, como por ejemplo la versión).
 +
*Lo primero que tenemos que especificar es la imagen de la que partimos '''''instruccion FROM'''''
 +
{{Ejemplo|
 +
<source lang=bash>
 +
;imagen en base a ubuntu 14.04
 +
FROM ubuntu:14.04
 +
</source>
 +
<source lang=bash>
 +
;imagen en base a debian
 +
FROM debian:stable
 +
 +
</source>
 +
 +
}}
 +
;MAINTAINER
 +
MAINTAINER <name>
 +
*Especifica el autor de la imagen y su correo
 +
MAINTAINER Manuel Romero <ManuelRomeroMiguel@gmail.com>
 +
;RUN
 +
RUN <command>
 +
RUN ["ejecutable", "parametro1", "parametro2"]
 +
 +
*Ejecuta cualquier comando en la imagen que estamos usando. El resultado de la ejecución se puede tomar para el siguiente paso en el dockfile, por ejemplo si ejecuto la instalación de apache, en el siguiente comando puedo contar que apache ya está instalado
 +
*Es un comando muy utilizado.
 +
*Si usamos apt-get install especificaremos el flag -y para que no haga falta que sea interactivo y tome la decisión por defecto
 +
*Añadimos a nuestro fichero las siguientes librerías
 +
<source lang=bash>
 +
#Ahora empezamos a instalar todos los paquetes necesarios
 +
 +
==Otros aspectos==
 +
*Instalar un contenedor como un servicio
 +
https://blog.marcnuri.com/docker-configurando-contenedor-servicio-linux/
 +
https://onthedock.github.io/post/170920-autoarranque-de-contenedores/
 +
</div>
 +
-->

Revisión de 04:33 8 nov 2022




Contenedor Vs Imagen

  • Estos conceptos son la base para utilizar docker.

Contenedor vs imagen.png
La imagen
  • La imagen es el fichero que nos va a permitir instalar esta especie de máquina virtual.
  • No se emula hardware, sino solo servicios (software: sistema de ficheros, sistema operativo y servicios), por lo que un conetenedor no es una máquina, aunque sí que tenga una ip. Sí que se puede ver como un dispositivo o nodo de la red independiente.
  • Podríamos hacer una comparación con la iso para instalar el sistema operativo, pero solo para tener una idea, ya que el concepto es diferente.
El contenedor
  • El contenedor será el software que corresponde al sistema corriendo con el cual podemos interactuar. Se instala a partir de una imagen y siempre dependerá de ella, es decir, no podremos eliminar la imagen mientras tenga un contenedor asociado.
  • En realidad el contenedor almacena los cambios que haya sobre la imagen y todo va siendo pequeños incrementos sobre un fichero base, lo que se vuelve un sistema muy robusto, ágil y ligero.


Contenedor Vs Imagen

  • También, a partir de un contenedor podemos crear una imagen con todo el software que tenga ese contenedor.
  • Cuando volvamos a desplegar la imagen creada en otro contenedor, tendremos disponible todo el software incluido.

Contenedor vs imagen 1.png


Crear un contenedor

  • Hay varias formas de crear un contenedor, y vamos poco a poco a aprenderlas según vayamos necesitando


Icon key points.gif

Crear un contenedor

Siempre a partir de una imagen



  • Lo primero que tendremos que hacer es descargar una imagen.

(Comment.gif: El nombre de las imágenes y de los contenedores consta de nombre:tag) 


 docker pull ubuntu:latest

(Comment.gif: Cuando creamos un contenedor (siempre a partir de una imagen), si esta no existe en local, intentará localizarla en la nube y la descargará, por lo que no necesitaremos hacer un pull de la misma )


docker run
  • Permite crear y arrancar un contenedor
  • En realidad ejecuta un comando en un nuevo contenedor, por lo tanto lo crea.
Creacion conenedor 1.png


Creando un contenedor a partir de una imagen del repositorio
  • Vamos a crear un contenedor a partir de la imagen ubuntu:latest;
  • Existe un repositorio de imágenes en la nube donde el comando docker va a ir a buscarlas cuando las necesite https://hub.docker.com/.
  • Podemos registrarnos, como en git', y aportar las imágenes que creemos (lo veremos a continuación) 
docker run ubuntu:latest

(Comment.gif: Este comando habrá creado un contenedor)



Ver todos los contenedores docker ps -a
  • Podemos ver todos los contenedores 
docker ps -a
  • Si no damos la opción -a solo se visualziarán los contenedores activos
Borrando un contenedor
docker rm
  • Como el contenedor tiene un nombre que el sistema le ha dado, vamos a borrarlo y crear otro asignando un nombre 
docker rm <nombre_del_contenedor>
Borrando una imagen
docker rmi
  • Igualmente podríamos elminar una imagen de nuestro sistema.

(Comment.gif: Si existe algún contenedor que dependa de esa imagen, no se podrá borrar) 


docker rmi <nombre_de_la_imagen>
Para ver los nombres de las imágenes en mi sistema (actualmente descargados) 
docker images
Crear un contenedor asignando el nombre
docker run --name nombre 
docker run --name web ubuntu:latest
  • Lo visualizamos 
docker ps -a


Terminal en el contenedor
interactivamente: docker run -ti ....
  • Con el contenedor creado previamente podemos ejectura acciones, pero si queremos interactuar con él, debemos de permitir abrir un terminal y establecer interacción
  • Para ello hemos de aportar el parámetro -t para poder abrir terminal y -i para interactuar 
docker run -ti --name web ubuntu:latest


  • Ahora para abrir un terminal, ejecutamos el comando bash 
docker run -ti --name web ubuntu:latest


Estableciendo un forward o mapeando puertos

Situación
  • Ahora tenemos un docker. Podremos acceder a él a través de la ip, ya que se ha creado una red interna entre el anfitrión y el contenedor.
  • La configuración de la red, se puede establecer, en linux, por defecto suele empezar con la red 172.17.0.0, por lo que se crea la siguiente situación
Docker forward 1.png


Estableciendo un forward o mapeando puertos
  • Si en el docker tenemos instalado un servidor web, como va a ser nuestro caso, y queremos que atienda nuestras solicitudes, sería fácil acceder a él a través de la ip.
  • Pero se presenta un problema en sistema windows y si queremos acceder a nuestro docker, desde otra máquina, ya que la red es interna, y en windows no se permite acceder al docker por ip.
  • La solución es mapear o realizar un fordward de puertos, de modo que estableceremos un puerto en nuestro anfitrión (el valor que queramos asignar por encima del 1024) que mapearemos al puerto 80 o 443 de nuestro docker, de manera que todas las solicitudes que reciba nuestro anfitrión se redirigan al servidor web del docker.
  • Podemos ver el escenario en la imagen siguiente:
Docker forward 2.png


Estableciendo un forward o mapeando puertos docker run -p puerto_anfitrion:puerto:docker ... 
#Primero borramos el docker que teníamos
docker rm web
#Lo volvemos a crear, mapeando puertos
docker run -ti -p 8080:80  --name web ubuntu:latest


Compartiendo carpetas entre anfitrión y docker

Situación
  • Ahora ocurre que el apache de docker va a ejecutar recursos que vamos a debemos tener almacenados en el docker
  • Esos recursos van a ser programas de php que escribiremos
  • Usaremos un EDI, por ejemplo phpstorm, para crear dichos recursos, pero el EDI, no lo vamos a ejectuar dentro del docker, sino en nuestra máquina anfitriona
Docker compartir carpeta 1.png


Compartiendo carpetas entre anfitrión y docker
  • Vamos a crear una carpeta compartida entre anfitrión y contenedor
  • De forma que todo lo que haya en esa carpeta y creemos en el anfitrión, estará disponible en el contenedor
  • La acción es bidireccional, todo lo que haya y creemos en el contenedor, estará disponible en el anfitrión
Docker compartir carpeta 2.png


Estableciendo un forward o mapeando puertos docker run -v dir/anfitrion:/dir/contenedor ... 
#Primero borramos el docker que teníamos
docker rm web
#Lo volvemos a crear, mapeando puertos
docker run -ti -p 8080:80  -v /home/user/docker:/var/www/html --name web ubuntu:latest</span>

(Comment.gif:

  • Se creará un directorio en local según especificquemos
  • Si trabajamos en linux, el directorio lo habrá creado docker, y por lo tanto será propiedad de root (hay que cambiar permisos)
  • En windows no existe esta circunstancia
  • Ahora ya podemos crear los proyectos con nuestro edi, y el apache del docker los encontrará para ejecutarlos

)



  • Vamos a instalar en el contenedor los paquetes que necesito para nuestra arquitectura web:
Apache
PHP
xdebug
  • Para ello vamos a la sección de instalación del sistem y realizamos las instalaciones correspondientes 
docker run -ti --name web ubuntu:latest



Obtenido de «https://es.wikieducator.org/index.php?title=Usuario:ManuelRomero/ProgramacionWeb/Docker/contenedorVsImagen&oldid=29866»