LINUX

Cómo configurar contenedores Apache con Docker en Fedora 22

En este artículo, aprenderemos sobre Docker, cómo usarlo para implementar Apache httpd y cómo puede compartirlo en Docker Hub. Primero vamos a aprender cómo extraer y usar imágenes alojadas en Docker Hub, y luego instalar Apache en una imagen de Fedora 22 de forma interactiva, después de eso vamos a aprender cómo usar un Dockerfile para hacer una imagen de una manera más rápida y más De manera elegante, finalmente vamos a publicar la imagen que hemos creado en Docker Hub, para que cualquiera pueda descargarla y usarla más tarde.

Instalar Docker y saludar al mundo

Requisitos

Necesitará al menos estas cosas para ejecutar Docker:

  • Necesita una versión de Kernel de 64 bits 3.10 o superior
  • Iptables 1.4: Docker lo utilizará para realizar la magia de la red, como la traducción de direcciones de red.
  • Git 1.7: Docker usa Git para realizar transacciones en repositorios, como Docker Hub
  • ps: esta utilidad está presente en la mayoría de los entornos y se proporciona en el paquete procps.
  • root: a pesar de que los usuarios normales pueden ejecutar el cliente Docker por TCP y otros medios, asumiremos que usted es root, en aras de la simplicidad

Instalar Docker usando dnf

Los siguientes comandos instalarán Docker

dnf update && dnf install docker

Nota: Todavía puede usar Yum en Fedora 22, pero está obsoleto a favor de DNF y no está presente en una instalación limpia.

Comprueba tu instalación

El primer comando que vamos a utilizar es información de la ventana acoplable, esto te da mucha información:

docker info

Intenta también versión docker:

docker version

Iniciar Docker como demonio

Debe iniciar una instancia de Docker que se encargue de nuestras solicitudes.

docker -d

Ahora configure la ventana acoplable para que comience con el sistema, por lo que no necesita ejecutar el comando anterior cada vez que reinicia.

chkconfig docker on

Digamos hola mundo con Busybox:

docker run -t busybox /bin/echo "hello world"

En este comando, le decimos a Docker que ejecute / bin / echo «hola mundo» en una instancia / contenedor de la imagen Busybox, que es un entorno POSIX mínimo basado en un solo binario y enlaces a él.

Si Docker no puede encontrar una imagen local de Busybox en su sistema, extraerá la imagen automáticamente de Docker Hub, como puede ver en la siguiente captura de pantalla:

Hola mundo con Busybox
Hola mundo con Busybox

Intente el mismo comando nuevamente, esta vez como Docker ya tiene la imagen de Busybox localmente, todo lo que verá es la salida de echo:

docker run -t busybox /bin/echo "hello world"

Intente también lo siguiente para entrar en el entorno del contenedor:

docker run -it busybox /bin/sh

Para salir y detener el contenedor utilice el Salida mando

Dockerizar Apache de forma interactiva

Extraiga / descargue la imagen de Fedora:

docker pull fedora:22

Ejecute un contenedor separado de la consola:

docker run -d -t fedora:22 /bin/bash

Enumere los contenedores en ejecución e identifíquelos por nombre de la siguiente manera

docker ps

enumerar con docker ps y adjuntar con docker attach

El nombre angry_nobel se le dio a nuestra instancia, así que adjuntemos:

docker attach angry_nobel

Nota: Cada vez que ejecute un contenedor se le dará un nuevo nombre, si necesita un nombre constante para su contenedor, debe usar el -nombre parámetro para ejecutar el comando docker.

Instalación de Apache

El siguiente comando actualizará la base de datos DNF, descargará la instalación de Apache (paquete httpd) y limpiará la caché DNF para hacer la imagen pequeña

dnf -y update && dnf -y install httpd && dnf -y clean all

Configurando Apache

Lo único que vamos a cambiar httpd.conf es el ServerName, esto hace que Apache se detenga para quejarse.

sed -i.orig 's/#ServerName/ServerName/' /etc/httpd/conf/httpd.conf

Establecer el entorno

Para hacer que Apache se ejecute en modo independiente, debe proporcionar cierta información en forma de variables de entorno, y también necesitará los directorios establecidos en estas variables, por lo que vamos a hacer esto con un pequeño script de shell que también iniciará Apache.

vi /etc/httpd/run_apache_foreground
#!/bin/bash

#set variables
APACHE_LOG_DI=R"/var/log/httpd"
APACHE_LOCK_DIR="/var/lock/httpd"
APACHE_RUN_USER="apache"
APACHE_RUN_GROUP="apache"
APACHE_PID_FILE="/var/run/httpd/httpd.pid"
APACHE_RUN_DIR="/var/run/httpd"

#create directories if necessary
if ! [ -d /var/run/httpd ]; then mkdir /var/run/httpd;fi
if ! [ -d /var/log/httpd ]; then mkdir /var/log/httpd;fi
if ! [ -d /var/lock/httpd ]; then mkdir /var/lock/httpd;fi

#run Apache
httpd -D FOREGROUND

Alternativamente, puede pegar y ejecutar este fragmento en el shell del contenedor:

dnf -y install git && git clone https://github.com/gaiada/run-apache-foreground.git && cd run-apach* && ./install && dnf erase git

El script en línea de arriba instalará Git, clonará este repositorio, coloque el script en su lugar y le preguntará si desea desinstalar Git.

Guardando el estado de su contenedor

Su contenedor ahora está listo para ejecutar Apache, ahora es el momento de guardar el estado actual de este contenedor en una imagen para poder usarlo cuando lo necesite.

Para salir del entorno del contenedor, debe presionar Ctrl + p seguido por Ctrl + q, si simplemente llama a exit en el shell, también detendrá el contenedor y perderá lo que ha hecho hasta ahora.

Una vez que regrese al host de Docker, use Docker commit seguido del contenedor y el nombre / etiqueta del repositorio que desee:

docker commit angry_nobel gaiada/apache

Ahora que guardó el estado del contenedor en una imagen, puede usar parada del acoplador en el contenedor en ejecución:

docker stop angry_nobel

Ejecuta y prueba tu imagen

Finalmente, ejecute un contenedor desde su nueva imagen y redirija las conexiones en el puerto 80 hacia él con:

docker run -p 80:80 -d -t gaiada/apache /etc/httpd/run_apache_foreground

En este punto, ya está ejecutando Apache en su contenedor, abra su navegador para acceder al servicio en http: // localhost y verá la página predeterminada de Apache de la siguiente manera

Página predeterminada de Apache que se ejecuta desde el contenedor Docker
Página predeterminada de Apache que se ejecuta desde el contenedor Docker

Dockerizar Apache con un Dockerfile

Ahora vamos a crear una nueva imagen de Apache, esta vez los pasos se escribirán en un Dockerfile, que se procesará para formar la imagen.

Primero, cree un directorio en el que colocaremos el Dockerfile e ingresaremos a este directorio:

mkdir apachedf; cd apachedf

Y luego crea un archivo llamado Dockerfile con el siguiente contenido:

FROM fedora:22

MAINTAINER Carlos Alberto
LABEL version="0.1"

RUN dnf -y update && dnf -y install httpd && dnf -y clean all

RUN [ -d /var/log/httpd ] || mkdir /var/log/httpd
RUN [ -d /var/run/httpd ] || mkdir /var/run/httpd
RUN [ -d /var/lock/httpd ] || mkdir /var/lock/httpd

RUN sed -i.orig 's/#ServerName/ServerName/' /etc/httpd/conf/httpd.conf

ENV APACHE_RUN_USER apache
ENV APACHE_RUN_GROUP apache
ENV APACHE_LOG_DIR /var/log/httpd
ENV APACHE_LOCK_DIR /var/lock/httpd
ENV APACHE_RUN_DIR /var/run/httpd
ENV APACHE_PID_FILE /var/run/httpd/httpd.pid

EXPOSE 80

CMD ["/usr/sbin/httpd", "-D", "FOREGROUND"]

Veamos qué hay en este Dockerfile:

DESDE – Esto le dice a Docker que vamos a usar Fedora 22 como imagen base.

MANTAINER y ETIQUETA – estos comandos son informativos y no tienen influencia directa en la imagen

CORRER – Automatizar los pasos que hemos realizado de forma interactiva, instalar Apache, crear directorios y editar httpd.conf

ENV – Establezca las variables de entorno, ahora ya no necesitamos el script run_apache_foreground.

EXPONER – Exponer el puerto 80 al mundo

CMD – Establezca el comando predeterminado en httpd, por lo que no es necesario hacer esto cada vez que iniciamos un nuevo contenedor.

Construye la imagen
Ahora vamos a construir la imagen y ponerle TAG gaiada / apachedf:

docker build -t gaiada/apachedf:0.1 .
construcción de Docker completa
construcción de Docker completa

Usar imágenes de docker enumere las imágenes locales y vea si su nueva imagen está allí:

docker images

Y luego ejecuta tu nueva imagen:

docker run -t -p 80:80 gaiada/apachedf

Eso es todo para el Dockerfile, el uso de esta función hace las cosas mucho más fáciles, rápidas y reproducibles.

Publicar tus imágenes

Hasta ahora, solo extraía imágenes de Docker Hub, pero también puede empujar su imagen y extraerlas más tarde según sea necesario. De hecho otros también pueden descargar tu imagen y usarla en sus sistemas sin necesidad de cambiar nada y ahora vamos a aprender cómo hacer que nuestra imagen esté disponible para otros en todo el mundo.

Creando cuenta

Para poder enviar su imagen a Docker Hub, debe crear una cuenta. Acceso https://hub.docker.com/account/signup/ y llene el siguiente formulario:

Página de registro de Docker Hub
Página de registro de Docker Hub

Acceso

Ingrese el siguiente comando y continúe con el nombre de inicio de sesión, la contraseña y el correo electrónico que proporcionó en la creación de su cuenta

docker login

Después de realizar el primer inicio de sesión, la información de su cuenta se registrará en ~ / .dockercfg

Emprendedor

Empuje la página al servidor con el empuje de la ventana acoplable [registry/]your_login / repository_name[:tag]

docker push docker.io/gaiada/apachedf

Es posible que vea algo como esto en su consola:

Imagen de Apache de inserción de Docker completa
Imagen de Apache de inserción de Docker completa

Conclusión

Ahora que sabe cómo Dockerizar Apache, intente incluir algunos módulos, Perl, PHP, proxy, HTTPS o lo que necesite. Espero que les haya gustado y que publiquen sus propias imágenes en Docker Hub.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada.

Botón volver arriba
Cerrar