GNU/Linux >> Tutoriales Linux >  >> Ubuntu

Cómo implementar NGINX Reverse Proxy en Docker

Introducción

Un proxy inverso intercepta las solicitudes entrantes y las dirige al servidor apropiado. Esto no solo acelera el rendimiento, sino que también fortalece la seguridad del servidor.

La forma más fácil de configurar y administrar proxies inversos es usar Nginx y Docker. Esta guía configura dos servicios web de muestra dentro de contenedores Docker y un proxy inverso Nginx para esos servicios.

En este tutorial, aprenderá a configurar un proxy inverso en Docker para dos servidores web de muestra.

Requisitos previos

  • Una cuenta de usuario con sudo privilegios
  • Una línea de comando/ventana de terminal (Ctrl-Alt-T )
  • Docker instalado en su sistema
  • Docker Compose instalado en su sistema
  • Un nombre de dominio registrado con un certificado SSL asociado

¿Por qué necesita un proxy inverso?

Mientras que el servidor proxy estándar protege a los clientes, el proxy inverso protege al servidor .

Un proxy inverso es un tipo de proxy configurado detrás del firewall de la red privada. Su función principal es interceptar el tráfico y dirigir una solicitud al servidor apropiado en el backend.

Las razones principales para usar un proxy inverso son mejorar la seguridad y rendimiento . Si tiene servicios que se ejecutan en varios pods, puede redirigir todas las solicitudes que ingresan a la red para que pasen por una cantidad de puertos específicos.

Además, los proxies inversos también pueden manejar el cifrado SSL, el almacenamiento en caché y la compresión de datos.

Paso 1:Cree un servicio web de muestra

1. Comience creando un nuevo directorio para el primer servicio web de muestra. En este tutorial, creamos un directorio example1 , pero puede usar el nombre que desee.

mkdir example1

2. Vaya a ese directorio:

cd example1

3. Cree un archivo de configuración YAML compuesto por docker para el primer contenedor para definir el servicio. Use un editor de texto de su elección (en este ejemplo, usamos Nano).

sudo nano docker-compose.yml

4. Luego, agregue el siguiente contenido en el archivo .yaml:

version: '2'
services:
 app:
  image: nginx
  volumes:
   - .:/usr/share/nginx/html
  ports:
   - "80"

El archivo docker-compose especifica que se trata de una aplicación servicio que utiliza nginx imagen. Monta la raíz de example1 desde el host de Docker a /usr/share/nginx/html/ . Finalmente, la configuración expone el servicio en el puerto 80 .

docker-compose.yml El archivo varía según el servicio que desee ejecutar. La configuración anterior es específica del servicio web que creamos para este tutorial.

4. Guarde y salga del archivo.

5. Mientras está dentro del mismo example1 directorio, cree un archivo de índice para el servicio web:

sudo nano index.html

6. Agregue algunas líneas simples para que aparezcan en la página web de muestra:

<!DOCTYPE html>
<html>
<head>
<title>Website 1</title>
</head>
<body>
<h1>Hello! This is the first sample website.</h1>
</body>
</html>

7. Guarde y cierre el archivo.

8. Compile el servicio recién creado con docker-compose comando:

sudo docker-compose build

Si usa una imagen preconstruida, como en este ejemplo, la salida responde con la aplicación usa una imagen, omitiendo .

9. A continuación, inicie el contenedor con:

sudo docker-compose up -d

Paso 2:Cree un segundo servicio web de muestra

Cree un segundo servicio web de muestra siguiendo el mismo proceso.

Asegúrate de volver al directorio de inicio si todavía estás en example1 . Para hacerlo, ejecute cd en la ventana de terminal.

1. Cree un nuevo directorio donde almacenará el archivo docker-compose e index para el segundo sitio web. Llamaremos a este directorio example2 .

mkdir example2

2. Vaya al ejemplo2 ejecutando:

cd example2

3. Cree un archivo docker-compose:

sudo nano docker-compose.yml

4. Defina el servicio usando las mismas especificaciones que en el Paso 1. Agregue el siguiente contenido al archivo:

version: '2'
services:
 app:
  image: nginx
  volumes:
   - .:/usr/share/nginx/html
  ports:
   - "80"

5. Guarde y salga del archivo.

6. Luego, cree un archivo de índice para el segundo servicio web ejecutando:

sudo nano index.html

7. Agregue contenido al archivo:

<!DOCTYPE html>
<html>
<head>
<title>Website 2</title>
</head>
<body>
<h1>Hello! This is the second sample website.</h1>
</body>
</html>

8. Guarde los cambios y salga del archivo.

9. Cree el segundo servicio e inicie el contenedor ejecutando los comandos:

sudo docker-compose build
sudo docker-compose up -d

Paso 3:lista de contenedores

Para verificar que los contenedores para ambos servicios estén activos y funcionando, enumere todos los contenedores con el comando:

docker ps -a

Debería ver contenedores para ambos servicios web enumerados en el resultado.

Paso 4:configurar el proxy inverso

A continuación, debe instalar y configurar un contenedor de proxy inverso. Esto requiere la creación de varios archivos y subdirectorios, que deben almacenarse dentro del proxy directorio.

Por lo tanto, el primer paso es crear y navegar en el proxy directorio. Para hacerlo, ejecute los comandos:

mkdir proxy
cd proxy

Configurar el Dockerfile

1. Una vez dentro del proxy directorio, cree un Dockerfile para una nueva imagen personalizada:

sudo nano Dockerfile

2. El archivo debe contener lo siguiente:

FROM nginx

COPY ./default.conf /etc/nginx/conf.d/default.conf

COPY ./backend-not-found.html /var/www/html/backend-not-found.html

COPY ./includes/ /etc/nginx/includes/

COPY ./ssl/ /etc/ssl/certs/nginx/

El Dockerfile se basa en la imagen nginx. También copia una serie de archivos de la máquina local:

  • la configuración predeterminada para el servicio de proxy
  • una respuesta de error HTML
  • Configuraciones y certificados de proxy y SSL

3. Guarde y salga del Dockerfile.

Configurar el archivo backend no encontrado

Cree un archivo de índice para un no encontrado respuesta:

sudo nano backend-not-found.html

Agrega el contenido:

<html>
<head><title>Proxy Backend Not Found</title></head>
<body>
<h2>Proxy Backend Not Found</h2>
</body>
</html>

3. Guarde los cambios y cierre el archivo.

Configurar el archivo default.conf

1. Cree el default.conf archivo dentro del directorio del proxy:

sudo nano default.conf

2. Agrega el contenido:

# web service1 config.
server {
listen 80;
listen 443 ssl http2;
server_name example1.test;

# Path for SSL config/key/certificate
ssl_certificate /etc/ssl/certs/nginx/example1.crt;
ssl_certificate_key /etc/ssl/certs/nginx/example1.key;
include /etc/nginx/includes/ssl.conf;

location / {
include /etc/nginx/includes/proxy.conf;
proxy_pass http://example_app_1;
}

access_log off;
error_log /var/log/nginx/error.log error;
}

# web service2 config.
server {
listen 80;
listen 443 ssl http2;
server_name example2.test;

# Path for SSL config/key/certificate
ssl_certificate /etc/ssl/certs/nginx/example2.crt;
ssl_certificate_key /etc/ssl/certs/nginx/example2.key;
include /etc/nginx/includes/ssl.conf;

location / {
include /etc/nginx/includes/proxy.conf;
proxy_pass http://example2_app_1;
}

access_log off;
error_log /var/log/nginx/error.log error;
}

# Default
server {
listen 80 default_server;

server_name _;
root /var/www/html;

charset UTF-8;

error_page 404 /backend-not-found.html;
location = /backend-not-found.html {
allow all;
}
location / {
return 404;
}

access_log off;
log_not_found off;
error_log /var/log/nginx/error.log error;
}

La configuración consta de dos servicios web:example1.test y ejemplo2.prueba . Ambos componentes del servidor escuchan el puerto 80 y dirigen a Nginx al certificado SSL apropiado.

Configure el archivo docker-compose.yml

1. Cree un nuevo docker-compose.yml archivo para el servicio proxy:

sudo nano docker-compose.yml

2. Copie y pegue el siguiente contenido en el archivo:

version: '2'
services:
proxy:
build: ./
networks:
- example1
- example2
ports:
- 80:80
- 443:443

networks:
example1:
external:
name: example1_default
example2:
external:
name: example2_default

En este archivo, conecta el proxy y las redes externas (los servicios web example1 y ejemplo2 ). Además, los puertos 80/443 del servicio de proxy están vinculados a los puertos 80/443 del host Docker.

Generar claves y certificados

1. Comience creando un subdirectorio (ssl ) dentro del proxy carpeta:

mkdir ssl

2. Navegue hasta ssl subdirectorio con:

cd ssl

3. A continuación, ejecute cada comando táctil que se enumera a continuación para crear los archivos necesarios:

touch example1.crt
touch example1.key
touch example2.crt
touch example2.key

4. Luego, use OpenSSL para generar claves y certificados para sus servicios web. Para el primer servicio web (ejemplo1 ), ejecute el comando:

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout example1.key -out example1.crt

El comando genera una clave privada RSA de 2048 bits y la almacena en example1.key archivo.

También se le pedirá que proporcione cierta información que se incorpora a la solicitud de certificado. Puede dejar algunos de los campos en blanco.

5. Repita el proceso para generar claves y certificados para el segundo servicio web (ejemplo2 ). Escriba el siguiente comando en la ventana de terminal:

sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout example2.key -out example2.crt

Esto genera una clave privada RSA de 2048 bits para example2 y lo guarda en el example2.key archivo.

Editar la configuración de proxy y SSL

1. Salga del ssl subdirectorio y de vuelta a proxy . Para hacerlo, use el comando:

cd ..

2. Luego, cree un nuevo subdirectorio con el nombre incluye :

mkdir includes

3. Navegue a incluye y crea los archivos proxy.conf y ssl.conf :

cd includes
touch proxy.conf
touch ssl.conf

4. A continuación, abra el proxy.conf archivo:

sudo nano proxy.conf

5. Agregue la siguiente configuración:

proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_buffering off;
proxy_request_buffering off;
proxy_http_version 1.1;
proxy_intercept_errors on;

6. Guarde y salga de proxy.conf .

7. Abra el archivo ssl.conf:

sudo nano ssl.conf

8. Pegue las siguientes líneas en el archivo:

ssl_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;

ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers 'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-
ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-
SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-
GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-
AES128-SHAECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-
SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:
DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-RSA-AES256-SHA:ECDHE-ECDSA-
DES-CBC3-SHA:ECDHE-RSA-DES-CBC3-SHA:EDH-RSA-DES-CBC3-SHA:AES128-GCM-SHA256:
AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:DES-
CBC3-SHA:!DSS';
ssl_prefer_server_ciphers on;

Editar el archivo de hosts

1. Regrese al proxy directorio:

cd

2. Abra el /etc/hosts archivo:

sudo nano etc/hosts

3. Agregue las siguientes líneas para asignar los nombres de host de los servicios web a la dirección IP privada de los hosts de Docker:

10.0.2.15 example1.test
10.0.2.15 example2.test

4. Guarde los cambios y cierre el archivo.

Paso 5:Inicie el proxy inverso

1. Con los archivos de configuración en su lugar, use el comando docker-compose para construir el contenedor:

sudo docker-compose build

2. Luego, ejecuta el contenedor:

sudo docker-compose up -d

3. Verifique que sepa que tiene tres contenedores:dos servicios web y un contenedor de proxy inverso:

sudo docker ps -a

Paso 6:compruebe si el proxy inverso funciona

Usa el curl Comando para verificar si los servicios web y el proxy inverso funcionan correctamente. Cada dominio debe responder con el resultado apropiado.

1. Ejecute el siguiente comando para verificar el primer servicio web:

sudo curl example1.test

La salida responde con el HTML creado para example1.test .

2. Luego, verifique que el segundo servicio web esté funcionando con el proxy inverso con:

sudo curl example2.test

La salida responde con example2.test HTML.


Ubuntu

  1. Cómo configurar un proxy inverso Nginx

  2. Cómo configurar Nginx como proxy inverso en Ubuntu 20.04

  3. Cómo implementar microservicios con Docker

  4. Cómo implementar un contenedor nginx con Docker en Linode

  5. Cómo instalar Odoo 11 en CentOS 7 con Nginx como proxy inverso

Cómo configurar Nginx como proxy inverso para Apache en Debian 11

Cómo instalar nginx como proxy inverso para Apache en Ubuntu 16.04

Cómo configurar Nginx como proxy inverso para Apache en Debian 11

Cómo configurar el proxy inverso de Nginx

¿Cómo configurar el proxy inverso de Nginx en Plesk?

Cómo implementar un servicio en un clúster de Docker Swarm