One place for hosting & domains

      segura

      Cómo implementar una aplicación Django escalable y segura con Kubernetes


      Introducción

      En este tutorial, implementará una aplicación de encuestas de Django en contenedor en un clúster de Kubernetes.

      Django es un poderoso framework web que puede ayudarle a poner en marcha rápidamente su aplicación o sitio web con Python. Incluye varias características convenientes como un mapeo objeto-relacional, la autenticación de usuarios y una interfaz administrativa personalizable para su aplicación. También incluye un marco de almacenamiento en caché y fomenta el diseño limpio de aplicaciones a través de su Despachador URL y sistema de Plantillas

      En Cómo crear una aplicación Django y Gunicorn con Docker, la aplicación de encuestas del Tutorial de Django fue modificada de acuerdo con la metodología de Twelve-Factor para crear aplicaciones web escalables y nativas en la nube. Esta configuración en contenedores se escaló y protegió con un proxy inverso Nginx y certificados TLS proporcionados por Let’s Encrypt en Cómo escalar y proteger una aplicación de Django con Docker, Nginx y Let’s Encrypt. En este tutorial final de la serie “De contenedores a Kubernetes con Django”, la aplicación de encuestas de Django modernizada se implementará en un clúster de Kubernetes.

      Kubernetes es un potente orquestador de contenedores de código abierto que automatiza la implementación, el escalamiento y la administración de aplicaciones en contenedores. Los objetos de Kubernetes, como ConfigMaps y Secrets, permiten centralizar y desvincular la configuración de los contenedores, mientras que los controladores como las implementaciones reinician automáticamente los contenedores fallidos y habilitar el escalamiento rápido de las réplicas de contenedores. El cifrado TLS se activa con un objeto Ingress y el controlador de Ingress de código abierto llamado ingress-nginx. El complemento cert-manager de Kubernetes renueva y emite certificados usando la autoridad de certificación de Let’s Encrypt gratuita.

      Requisitos previos

      Para seguir este tutorial, necesitará lo siguiente:

      • Un clúster de Kubernetes 1.15, o una versión posterior, con control de acceso basado en roles (RBCA) activado. Esta configuración usará un clúster de Kubernetes de DigitalOcean, pero puede crear un clúster usando otro método.
      • La herramienta de línea de comandos kubectl instalada en su equipo local y configurada para conectarse a su clúster. Puede leer más sobre la instalación de kubectl en la documentación oficial. Si está usando un clúster de Kubernetes de DigitalOcean, consulte Cómo conectarse a un clúster Kubernetes de DigitalOcean para aprender a conectarse a su clúster usando kubectl.
      • Un nombre de dominio registrado. Para este tutorial, se utilizará your_domain.com en todo momento. Puede obtener un ejemplar gratis en Freenom o utilizar el registrador de dominios que desee.
      • Un controlador de Ingress ingress-nginx y el administrador de certificados TLS cert-manager instalado en su clúster y configurado para emitir certificados TLS. Para aprender a instalar y configurar un Ingress con cert-manager, consulte Cómo configurar un Ingress de Nginx con Cert-Manager en Kubernetes de DigitalOcean.
      • Un registro DNS A con your_domain.com orientado a la dirección IP pública del equilibrador de cargas de Ingress. Si usa DigitalOcean para administrar los registros DNS de su dominio, consulte Cómo administrar registros DNS para aprender a crear registros A.
      • Un depósito de almacenamiento de objetos S3, como un Space de DigitalOcean, para almacenar los archivos estáticos de su proyecto de Django y un conjunto de claves de acceso para ese espacio. Para obtener información sobre cómo crear Spaces, consulte la documentación de Cómo crear Spaces. Para obtener información sobre cómo crear claves de acceso para Spaces, consulte Compartir el acceso a Spaces con claves de acceso. Con cambios menores, puede usar cualquier servicio de almacenamiento de objetos que admita el complemento django-storages
      • Una instancia de un servidor de PostgreSQL, una base de datos y un usuario para su aplicación de Django. Con cambios menores, puede usar cualquier base de datos que admita Django.
      • Un Docker Hub cuenta y repositorio público. Para obtener más información sobre cómo crearlos, consulte Repositorios de la documentación de Docker.
      • El motor Docker instalado en su máquina local. Consulte Cómo instalar y usar Docker en Ubuntu 18.04 para obtener más información.

      Una vez que haya configurado estos componentes, estará listo para comenzar con esta guía.

      Paso 1: Clonar y probar la aplicación

      En este paso, clonaremos el código de la aplicación de GitHub y configuraremos ajustes como las credenciales de la base de datos y las claves de almacenamiento de objetos.

      El código de la aplicación y Dockerfile se encuentran en la rama polls-docker del repositorio de GitHub de la aplicacipon Polls en el tutorial de Django. Este repositorio contiene el código para la aplicación Polls de muestra de la documentación de Django, que le enseña cómo crear una aplicación de encuestas desde cero.

      La rama polls-docker contiene una versión con Docker de esta aplicación Polls. Para obtener información sobre cómo se modificó la aplicación Polls para que funcionara de forma eficaz en un entorno de contenedores, consulte Cómo crear una aplicación de Django y Gunicorn con Docker.

      Comience usando git para clonar la rama polls-docker del repositorio de GitHub de la aplicación Polls del tutorial de Django en su máquina local:

      • git clone --single-branch --branch polls-docker https://github.com/do-community/django-polls.git

      Diríjase al directorio django-polls:

      Este directorio contiene el código de Python de la aplicación de Django, un Dockerfile que Docker utilizará para crear la imagen del contenedor, y un archivo env que contiene una lista de las variables de entorno que se pasarán al entorno de ejecución del contenedor. Inspeccione el Dockerfile:

      Output

      FROM python:3.7.4-alpine3.10 ADD django-polls/requirements.txt /app/requirements.txt RUN set -ex && apk add --no-cache --virtual .build-deps postgresql-dev build-base && python -m venv /env && /env/bin/pip install --upgrade pip && /env/bin/pip install --no-cache-dir -r /app/requirements.txt && runDeps="$(scanelf --needed --nobanner --recursive /env | awk '{ gsub(/,/, "nso:", $2); print "so:" $2 }' | sort -u | xargs -r apk info --installed | sort -u)" && apk add --virtual rundeps $runDeps && apk del .build-deps ADD django-polls /app WORKDIR /app ENV VIRTUAL_ENV /env ENV PATH /env/bin:$PATH EXPOSE 8000 CMD ["gunicorn", "--bind", ":8000", "--workers", "3", "mysite.wsgi"]

      Este Dockerfile utiliza la imagen de Docker oficial de Python 3.7.4 como base e instala los requisitos del paquete de Python de Django y Gunicorn, tal como se define en el archivo django-polls/requirements.txt. A continuación, elimina algunos archivos de compilación innecesarios, copia el código de la aplicación en la imagen y establece el PATH de ejecución. Por último, declara que el puerto 8000 se utilizará para aceptar conexiones de contenedores entrantes y ejecuta gunicorn con 3 trabajadores, escuchando en el puerto 8000.

      Para obtener más información sobre cada uno de los pasos de este Dockerfile, consulte el Paso 6 de Cómo crear una aplicación de Django y Gunicorn con Docker.

      Ahora, compile la imagen con docker build:

      Nombramos la imagen polls con el indicador -t y pasamos el directorio actual como contexto de compilación, el conjunto de archivos a los que se debe hacer referencia al construir la imagen.

      Una vez que Docker haya compilado y etiquetado la imagen, enumere las imágenes disponibles utilizando docker images:

      Debería ver la imagen polls enumerada:

      OutputREPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
      polls               latest              80ec4f33aae1        2 weeks ago         197MB
      python              3.7.4-alpine3.10    f309434dea3a        8 months ago        98.7MB
      

      Antes de ejecutar el contenedor de Django, debemos configurar su entorno de ejecución utilizando el archivo env presente en el directorio actual. Este archivo se pasará al comando docker run que se utiliza para ejecutar el contenedor y Docker insertará las variables de entorno configuradas en el entorno en ejecución del contenedor.

      Abra el archivo env con nano o su editor favorito:

      django-polls/env

      DJANGO_SECRET_KEY=
      DEBUG=True
      DJANGO_ALLOWED_HOSTS=
      DATABASE_ENGINE=postgresql_psycopg2
      DATABASE_NAME=polls
      DATABASE_USERNAME=
      DATABASE_PASSWORD=
      DATABASE_HOST=
      DATABASE_PORT=
      STATIC_ACCESS_KEY_ID=
      STATIC_SECRET_KEY=
      STATIC_BUCKET_NAME=
      STATIC_ENDPOINT_URL=
      DJANGO_LOGLEVEL=info
      

      Complete los valores que faltan para las siguientes claves:

      • DJANGO_SECRET_KEY: establézcala en un valor único e impredecible, como se detalla en la documentación de Django. Se proporciona un método para generar esta clave en la sección Ajustar la configuración de la aplicación del tutorial Aplicaciones escalables de Django.
      • DJANGO_ALLOWED_HOSTS: esta variable asegura la aplicación y evita ataques a través del encabezado de host HTTP. Para propósitos de prueba, establézcala en *, un comodín que coincidirá con todos los hosts. En producción, debe establecerlo en your_domain.com. Para obtener más información sobre esta configuración de Django, consulte la sección Configuración principal en la documentación de Django.
      • DATABASE_USERNAME: establézcalo en el usuario de la base de datos de PostgreSQL creado en los pasos de requisitos previos.
      • DATABASE_NAME: establézcalo en polls o el nombre de la base de datos de PostgreSQL creado en los pasos de requisitos previos.
      • DATABASE_PASSWORD: establézcala en la contraseña de la base de datos de PostgreSQL creada en los pasos de requisitos previos.
      • DATABASE_HOST: establézcalo en el nombre de host de su base de datos.
      • DATABASE_PORT: establézcalo en el puerto de su base de datos.
      • STATIC_ACCESS_KEY_ID: establézcala en la clave de acceso de Space o en el almacenamiento de objetos.
      • STATIC_SECRET_KEY: establézcala en Secret de la clave de acceso de su Space o en el almacenamiento de objetos.
      • STATIC_BUCKET_NAME: establézcalo en el nombre de su Space o en el depósito de almacenamiento de objetos.
      • STATIC_ENDPOINT_URL: establézcala en la URL de extremo de Spaces o del almacenamiento del objeto que corresponda, por ejemplo, https://your_space_name.nyc3.digitaloceanspaces.com, si su Space está ubicado en la región nyc3.

      Una vez que haya finalizado la edición, guarde y cierre el archivo.

      En el siguiente paso, ejecutaremos el contenedor configurado a nivel local y crearemos el esquema de la base de datos. También cargaremos activos estáticos como hojas de estilos e imágenes al almacenamiento de objetos.

      Paso 2: Crear el esquema de la base de datos y cargar activos en el almacenamiento de objetos

      Con el contenedor creado y configurado, utilizaremos docker run para anular el CMD establecido en Dockerfile y crear el esquema de la base de datos utilizando los comandos manage.py makemigrations y manage.py migrate:

      • docker run --env-file env polls sh -c "python manage.py makemigrations && python manage.py migrate"

      Ejecutamos la imagen del contenedor polls:latest, pasamos el archivo de variables de entorno que acabamos de modificar y anulamos el comando de Dockerfile con sh -c "python manage.py makemigrations && python manage.py migrate", lo que creará el esquema de la base de datos definido mediante el código de la aplicación.

      Si lo está ejecutando por primera vez, debería ver lo siguiente:

      Output

      No changes detected Operations to perform: Apply all migrations: admin, auth, contenttypes, polls, sessions Running migrations: Applying contenttypes.0001_initial... OK Applying auth.0001_initial... OK Applying admin.0001_initial... OK Applying admin.0002_logentry_remove_auto_add... OK Applying admin.0003_logentry_add_action_flag_choices... OK Applying contenttypes.0002_remove_content_type_name... OK Applying auth.0002_alter_permission_name_max_length... OK Applying auth.0003_alter_user_email_max_length... OK Applying auth.0004_alter_user_username_opts... OK Applying auth.0005_alter_user_last_login_null... OK Applying auth.0006_require_contenttypes_0002... OK Applying auth.0007_alter_validators_add_error_messages... OK Applying auth.0008_alter_user_username_max_length... OK Applying auth.0009_alter_user_last_name_max_length... OK Applying auth.0010_alter_group_name_max_length... OK Applying auth.0011_update_proxy_permissions... OK Applying polls.0001_initial... OK Applying sessions.0001_initial... OK

      Esto indica que el esquema de la base de datos se ha creado correctamente.

      Si no está ejecutando migrate por primera vez, Django realizará un no-op a menos que el esquema de la base de datos haya cambiado.

      A continuación, ejecutaremos otra instancia del contenedor de la aplicación y utilizaremos una shell interactiva en su interior para crear un usuario administrativo para el proyecto de Django.

      • docker run -i -t --env-file env polls sh

      Esto le proporcionará una línea de comandos de shell dentro del contenedor en ejecución que puede usar para crear el usuario de Django:

      • python manage.py createsuperuser

      Ingrese un nombre de usuario, una dirección de correo electrónico y una contraseña para su usuario y, una vez que haya creado el usuario, presione CTRL+D para salir del contenedor y cerrarlo.

      Por último, generaremos los archivos estáticos de la aplicación y los subiremos al Space de DigitalOcean utilizando collectstatic. Tenga en cuenta que esta operación puede tardar un poco en completarse.

      • docker run --env-file env polls sh -c "python manage.py collectstatic --noinput"

      Una vez que estos archivos se hayan generado y cargado, obtendrá el siguiente resultado.

      Output

      121 static files copied.

      Ahora, podemos ejecutar la aplicación:

      • docker run --env-file env -p 80:8000 polls

      Output

      [2019-10-17 21:23:36 +0000] [1] [INFO] Starting gunicorn 19.9.0 [2019-10-17 21:23:36 +0000] [1] [INFO] Listening at: http://0.0.0.0:8000 (1) [2019-10-17 21:23:36 +0000] [1] [INFO] Using worker: sync [2019-10-17 21:23:36 +0000] [7] [INFO] Booting worker with pid: 7 [2019-10-17 21:23:36 +0000] [8] [INFO] Booting worker with pid: 8 [2019-10-17 21:23:36 +0000] [9] [INFO] Booting worker with pid: 9

      Aquí, ejecutamos el comando predeterminado definido en el Dockerfile, gunicorn --bind :8000 --workers 3 mysite.wsgi:application y exponemos el puerto del contenedor 8000 para que el puerto 80 en su máquina local se asigne al puerto 8000 del contenedor polls.

      Ahora, debería poder navegar a la aplicación polls desde su navegador web al http://localhost en la barra de direcciones URL. Dado que no hay una ruta definida para la ruta / , es probable que reciba un error de 404 Page Not Found (Página no encontrada), lo que es de esperar.

      Diríjase a http://localhost/polls para ver la interfaz de la aplicación Polls:

      Interfaz de la aplicación Polls

      Para ver la interfaz administrativa, visite http://localhost/admin. Debería ver la ventana de autenticación de administración de la aplicación Polls:

      Página de autenticación de administración de Polls

      Ingrese el nombre de usuario administrativo y la contraseña que creó con el comando createsuperuser.

      Después de la autenticación, podrá acceder a la interfaz administrativa de la aplicación Polls:

      Interfaz principal de administración de Polls

      Tenga en cuenta que los que los recursos estáticos de las aplicaciones admin y polls se entregan directamente desde el almacenamiento de objetos. Para confirmar esto, consulte Prueba de la entrega de archivos estáticos de Spaces.

      Cuando haya terminado de explorar, presione CTRL+C en la ventana de terminal que está ejecutando el contenedor de Docker para cerrar el contenedor.

      Con la imagen de Docker de la aplicación de Django probada, los activos estáticos que se cargan en el almacenamiento de objetos y el esquema de la base de datos configurado y listo para ser utilizado en su aplicación, estará listo para subir la imagen de su aplicación de Django a un registro de imágenes como Docker Hub.

      Paso 3: Introducir la imagen de la aplicación de Django en Docker Hub

      Para implementar su aplicación en Kubernetes, la imagen de su aplicación debe cargarse en un registro como Docker Hub. Kubernetes extraerá la imagen de la aplicación de su repositorio y luego la implementará en su clúster.

      Puede usar un registro de Docker privado, como DigitalOcean Container Registry, actualmente gratuito en Early Access o un registro de Docker público como Docker Hub. Docker Hub también le permite crear repositorios de Docker privados. Un repositorio público permite a cualquiera ver y extraer las imágenes del contenedor, mientras que un repositorio privado permite restringir el acceso a usted y a los miembros de su equipo.

      En este tutorial, introduciremos la imagen de Django en el repositorio de Docker Hub público creado en los requisitos previos. También puede introducir su imagen en un repositorio privado, pero extraer imágenes de un repositorio privado no es el tema de este artículo. Para obtener más información sobre la autenticación de Kubernetes con Docker Hub y la extracción de imágenes privadas, consulte Extraer una imagen de un registro privado en la documentación de Kubernetes.

      Comience iniciando sesión en Docker Hub en su máquina local:

      Output

      Login with your Docker ID to push and pull images from Docker Hub. If you don't have a Docker ID, head over to https://hub.docker.com to create one. Username:

      Ingrese su nombre de usuario y contraseña de Docker Hub para iniciar sesión.

      La imagen de Django actualmente tiene la etiqueta polls:latest. Para introducirla en su repositorio de Docker Hub, vuelva a etiquetar la imagen con su nombre de usuario de Docker Hub y nombre de repositorio:

      • docker tag polls:latest your_dockerhub_username/your_dockerhub_repo_name:latest

      Introduzca la imagen en el repositorio:

      • docker push sammy/sammy-django:latest

      En este tutorial, el nombre de usuario de Docker Hub es sammy y el nombre de repositorio es sammy-django. Debe sustituir estos valores por su propio nombre de usuario y nombre de repositorio de Docker Hub.

      Verá un resultado que se actualiza a medida que las capas de imágenes se insertan en Docker Hub.

      Ahora que su imagen está disponible para Kubernetes en Docker Hub, puede comenzar a implementarla en su clúster.

      Paso 4: Configurar ConfigMap

      Cuando ejecutamos el contenedor de Django a nivel local, pasamos el archivo env a docker run para insertar variables de configuración en el entorno de tiempo de ejecución. En Kubernetes, las variables de configuración pueden insertarse usando ConfigMaps y Secrets.

      ConfigMaps debe usarse para almacenar información de configuración no confidencial, la configuración de la aplicación, mientras que Secrets debe usarse para información confidencial, como claves de API y credenciales de la base de datos. Ambos se insertan en contenedores de forma similar, pero Secrets tienen funciones de control de acceso y seguridad adicionales como encriptación en reposo. Secrets también almacenan datos en base64, mientras que ConfigMaps almacenan datos en texto simple.

      Para comenzar, cree un directorio llamado yaml en el que almacenaremos nuestros manifiestos de Kubernetes. Diríjase al directorio.

      Abra un archivo llamado polls-configmap.yaml en nano o su editor de texto preferido:

      • nano polls-configmap.yaml

      Pegue el siguiente manifiesto de ConfigMap:

      polls-configmap.yaml

      apiVersion: v1
      kind: ConfigMap
      metadata:
        name: polls-config
      data:
        DJANGO_ALLOWED_HOSTS: "*"
        STATIC_ENDPOINT_URL: "https://your_space_name.space_region.digitaloceanspaces.com"
        STATIC_BUCKET_NAME: "your_space_name"
        DJANGO_LOGLEVEL: "info"
        DEBUG: "True"
        DATABASE_ENGINE: "postgresql_psycopg2"
      

      Extrajimos la configuración no sensible del archivo env modificado en el Paso 1 y la pegamos en un manifiesto de ConfigMap. El objeto ConfigMap se llama polls-config. Copie los mismos valores que ingresó en el archivo env en el paso anterior.

      Para propósitos de prueba, establezca DJANGO_ALLOWED_HOSTS como * para desactivar el filtrado del encabezado de host. En un entorno de producción, debe establecerlo en el dominio de su aplicación.

      Cuando haya terminado de editar el archivo, guárdelo y ciérrelo.

      Cree ConfigMap en su clúster usando kubectl apply:

      • kubectl apply -f polls-configmap.yaml

      Output

      configmap/polls-config created

      Después de crear ConfigMap, crearemos el Secret que usó nuestra aplicación en el siguiente paso.

      Paso 5: Configurar Secret

      Los valores de Secret deben estar codificados en base64, lo que significa que crear objetos de Secret en su clúster es ligeramente más complicado que crear ConfigMaps. Puede repetir el proceso del paso anterior, codificando de forma manual los valores de Secret de base64 y pegándolos en un archivo de manifiesto. También puede crearlos usando un archivo de variable de entorno, kubectl create y el indicador --from-env-file, que realizaremos en este paso.

      Una vez más, usaremos el archivo env del Paso 1, eliminando las variables insertadas en ConfigMap. Cree una copia del archivo env llamado polls-secrets en el directorio yaml:

      • cp ../env ./polls-secrets

      Edite el archivo en el editor de su preferencia:

      polls-secrets

      DJANGO_SECRET_KEY=
      DEBUG=True
      DJANGO_ALLOWED_HOSTS=
      DATABASE_ENGINE=postgresql_psycopg2
      DATABASE_NAME=polls
      DATABASE_USERNAME=
      DATABASE_PASSWORD=
      DATABASE_HOST=
      DATABASE_PORT=
      STATIC_ACCESS_KEY_ID=
      STATIC_SECRET_KEY=
      STATIC_BUCKET_NAME=
      STATIC_ENDPOINT_URL=
      DJANGO_LOGLEVEL=info
      

      Elimine todas las variables insertadas en el manifiesto de ConfigMap. Cuando haya terminado, debe verse así:

      polls-secrets

      DJANGO_SECRET_KEY=your_secret_key
      DATABASE_NAME=polls
      DATABASE_USERNAME=your_django_db_user
      DATABASE_PASSWORD=your_django_db_user_password
      DATABASE_HOST=your_db_host
      DATABASE_PORT=your_db_port
      STATIC_ACCESS_KEY_ID=your_space_access_key
      STATIC_SECRET_KEY=your_space_access_key_secret
      

      Asegúrese de usar los mismos valores que se utilizan en el Paso 1. Cuando haya terminado, guarde y cierre el archivo.

      Cree el Secret en su clúster usando kubectl create secret:

      • kubectl create secret generic polls-secret --from-env-file=poll-secrets

      Output

      secret/polls-secret created

      Aquí creamos un objeto Secret llamado polls-secret y pasamos el archivo de secrets que acabamos de crear.

      Puede inspeccionar el Secret usando kubectl describe:

      • kubectl describe secret polls-secret

      Output

      Name: polls-secret Namespace: default Labels: <none> Annotations: <none> Type: Opaque Data ==== DATABASE_PASSWORD: 8 bytes DATABASE_PORT: 5 bytes DATABASE_USERNAME: 5 bytes DJANGO_SECRET_KEY: 14 bytes STATIC_ACCESS_KEY_ID: 20 bytes STATIC_SECRET_KEY: 43 bytes DATABASE_HOST: 47 bytes DATABASE_NAME: 5 bytes

      En este punto, almacenó la configuración de su aplicación en el clúster de Kubernetes usando los tipos de objeto Secret y ConfigMap. Ahora estamos listos para implementar la aplicación en el clúster.

      Paso 6: Implementar la aplicación de Django usando una implementación

      En este paso, creará una implementación para su aplicación de Django. Una implementación de Kubernetes es un controlador que puede usarse para administrar aplicaciones sin estado en su clúster. Un controlador es un bucle de control que regula las cargas de trabajo aumentándolas o reduciéndolas. Los controladores también reinician y eliminan los contenedores fallidos.

      Las implementaciones controlan uno o más Pods, la unidad implementable más pequeña de un clúster de Kubernetes. Los Pods están compuestos por uno o más contenedores. Para obtener más información sobre los diferentes tipos de cargas de trabajo que puede iniciar, consulte Introducción a Kubernetes.

      Empiece por abrir un archivo llamado polls-deployment.yaml en su editor favorito:

      • nano polls-deployment.yaml

      Pegue el siguiente manifiesto de implementación:

      polls-deployment.yaml

      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: polls-app
        labels:
          app: polls
      spec:
          replicas: 2
        selector:
          matchLabels:
            app: polls
        template:
          metadata:
            labels:
              app: polls
          spec:
            containers:
              - image: your_dockerhub_username/app_repo_name:latest
                name: polls
                envFrom:
                - secretRef:
                    name: polls-secret
                - configMapRef:
                    name: polls-config
                ports:
                  - containerPort: 8000
                    name: gunicorn
      

      Complete el nombre de la imagen del contenedor correspondiente, haciendo referencia a la imagen de Django Polls que agregó a Docker Hub en el Paso 2.

      Aquí definimos una implementación de Kubernetes llamada polls-app y la etiquetamos con el par clave-valor app: polls. Especificamos que queremos ejecutar dos réplicas del Pod especificado debajo del campo template.

      Usando envFrom con secretRef y configMapRef, especificamos que todos los datos del Secret polls-secret y el ConfigMap polls-config deben insertarse en los contenedores como variables de entorno. Las claves ConfigMap y Secret se convierten en los nombres de las variables de entorno.

      Por último, exponemos el containerPort 8000 y lo nombramos gunicorn.

      Para obtener más información sobre la configuración de las implementaciones de Kubernetes, consulte Implementaciones en la documentación de Kubernetes.

      Cuando haya terminado de editar el archivo, guárdelo y ciérrelo.

      Cree la implementación en su clúster usando kubectl apply -f:

      • kubectl apply -f polls-deployment.yaml
      • deployment.apps/polls-app created

      Compruebe que la implementación se implementó correctamente usando kubectl get:

      • kubectl get deploy polls-app

      Output

      NAME READY UP-TO-DATE AVAILABLE AGE polls-app 2/2 2 2 6m38s

      Si encuentra un error o considera que algo no está funcionando, puede usar kubectl describe para inspeccionar la implementación fallida:

      Puede inspeccionar los dos Pods usando kubectl get pod:

      Output

      NAME READY STATUS RESTARTS AGE polls-app-847f8ccbf4-2stf7 1/1 Running 0 6m42s polls-app-847f8ccbf4-tqpwm 1/1 Running 0 6m57s

      Ahora hay dos réplicas de su aplicación de Django ejecutándose en el clúster. Para acceder a la aplicación, es necesario crear un Service de Kubernetes, lo cual es lo que haremos a continuación.

      En este paso, creará un Service para su aplicación de Django. Un Service de Kubernetes es una abstracción que le permite exponer un conjunto de Pods en ejecución como servicio de red. Mediante un Service, puede crear un extremo estable para su aplicación que no cambia a medida que los Pods mueren y se vuelvan a crear.

      Existen varios tipos de Service, incluidos ClusterIP Services, que exponen el servicio en un IP interno del clúster, NodePort Services que exponen el servicio en cada Nodo en un puerto estático llamado NodePort y LoadBalancer Services que proporcionan un equilibrador de carga en la nube para dirigir el tráfico externo a los Pods de su clúster (a través de NodePorts, que crea automáticamente). Para obtener más información sobre esos servicios, consulte el artículo Service en la documentación de Kubernetes.

      En nuestra configuración final, usaremos un Service ClusterIP que se expone usando un Ingress y el controlador de Ingress configurado en los requisitos previos de esta guía. Por ahora, para comprobar que todo funciona correctamente, crearemos un servicio de NodePort temporal para acceder a la aplicación de Django.

      Comience creando un archivo llamado polls-svc.yaml usando el editor de su preferencia:

      Pegue el siguiente manifiesto de Service:

      polls-svc.yaml

      apiVersion: v1
      kind: Service
      metadata:
        name: polls
        labels:
          app: polls
      spec:
        type: NodePort
        selector:
          app: polls
        ports:
          - port: 8000
            targetPort: 8000
      

      Aquí creamos un Service NodePort llamado polls y le asignamos la etiqueta app: polls. A continuación, seleccionamos los Pods backend con la etiqueta app: polls y orientamos sus puertos 8000.

      Cuando haya terminado de editar el archivo, guárdelo y ciérrelo.

      Implemente el Service usando kubectl apply:

      • kubectl apply -f polls-svc.yaml

      Output

      service/polls created

      Confirme que su Service se creó usando kubectl get svc:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE polls NodePort 10.245.197.189 <none> 8000:32654/TCP 59s

      Este resultado muestra la IP y NodePort internos del clúster de Service (32654). Para conectarse al servicio, se necesitan las direcciones IP externas de los nodos del clúster:

      Output

      NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME pool-7no0qd9e0-364fd Ready <none> 27h v1.18.8 10.118.0.5 203.0.113.1 Debian GNU/Linux 10 (buster) 4.19.0-10-cloud-amd64 docker://18.9.9 pool-7no0qd9e0-364fi Ready <none> 27h v1.18.8 10.118.0.4 203.0.113.2 Debian GNU/Linux 10 (buster) 4.19.0-10-cloud-amd64 docker://18.9.9 pool-7no0qd9e0-364fv Ready <none> 27h v1.18.8 10.118.0.3 203.0.113.3 Debian GNU/Linux 10 (buster) 4.19.0-10-cloud-amd64 docker://18.9.9

      En su navegador web, visite su aplicación Polls usando la dirección IP externa de cualquier nodo y el NodePort. Dado el resultado anterior, la URL de la aplicación sería la siguiente: http://203.0.113.1:32654/polls.

      Debería poder ver la misma interfaz de la aplicación Polls a la que accedió a nivel local en el Paso 1:

      Interfaz de la aplicación Polls

      Puede repetir la misma prueba usando la ruta /admin: http://203.0.113.1:32654/admin. Debería ver la misma interfaz administrativa que antes:

      Página de autenticación de administración de Polls

      En esta etapa, ya implementó dos réplicas del contenedor de la aplicación Polls de Django usando una implementación. También creó un extremo de red estable para estas dos réplicas e hizo que se pueda acceder a ellas externamente usando un servicio de NodePort

      El paso final de este tutorial es proteger el tráfico externo a su aplicación usando HTTPS. Para ello, usaremos el controlador de Ingress-nginx instalado en los requisitos previos y crearemos un objeto de Ingress para dirigir el tráfico externo al servicio de Kubernetes de polls.

      Paso 8: Configurar HTTPS usando el Ingress y cert-manager de Nginx

      Los Ingress de Kubernetes le permiten dirigir de manera flexible el tráfico del exterior de su clúster de Kubernetes a servicios dentro de su clúster. Esto se realiza usando objetos de Ingress, que definen reglas para dirigir el tráfico HTTP y HTTPS a servicios de Kubernetes, y controladores de Ingress, que implementan las reglas equilibrando la carga de tráfico y dirigiéndola a los servicios de backend correspondientes.

      En los requisitos previos, instaló el controlador de Ingress-nginx y el complemento para automatizar certificados TLS cert-manager. También ha configurado el ClusterIssuers de ensayo y producción de su dominio usando la autoridad de certificación Let’s Encrypt, y ha creado un Ingress para probar la emisión de certificados y el cifrado TLS en dos servicios de backend ficticios. Antes de continuar con este paso, debe eliminar el Ingress echo-ingress creado en el tutorial de requisitos previos:

      • kubectl delete ingress echo-ingress

      Si desea, también puede eliminar los servicios y las implementaciones ficticios usando kubectl delete svc y kubectl delete deploy, pero no es necesario que lo haga para completar este tutorial.

      También debería haber creado un registro DNS A con your_domain.com orientado a la dirección IP pública del equilibrador de cargas de Ingress. Si usa un equilibrador de carga de DigitalOcean, puede encontrar esta dirección IP en la sección Equilibradores de carga del panel de control. Si también usa DigitalOcean para administrar los registros DNS de su dominio, consulte Cómo administrar registros DNS para aprender a crear registros A.

      Si usa Kubernetes de DigitalOcean, también asegúrese de implementar la solución descrita en el Paso 5 de Cómo configurar un Ingress de Nginx con Cert-Manager en Kubernetes de DigitalOcean.

      Una vez que tenga un registro A que apunte al equilibrador de carga del controlador de Ingress, puede crear un Ingress para your_domain.com y el servicio polls.

      Abra un archivo llamado polls-ingress.yaml usando el editor de su preferencia:

      Pegue el siguiente manifiesto de Ingress:

      [polls-ingress.yaml]
      apiVersion: networking.k8s.io/v1beta1
      kind: Ingress
      metadata:
        name: polls-ingress
        annotations:
          kubernetes.io/ingress.class: "nginx"
          cert-manager.io/cluster-issuer: "letsencrypt-staging"
      spec:
        tls:
        - hosts:
          - your_domain.com
          secretName: polls-tls
        rules:
        - host: your_domain.com
          http:
            paths:
            - backend:
                serviceName: polls
                servicePort: 8000
      

      Creamos un objeto de Ingress llamado polls-ingress y lo anotamos para indicarle al plano de control que utilice el controlador de Ingress-nginx y el ClusterIssuer de ensayo. También habilitamos TLS para your_domain.com y almacenamos el certificado y la clave privada en un secret llamado polls-tls. Por último, definimos una regla para dirigir el tráfico del host your_domain.com al servicio polls del puerto 8000.

      Cuando haya terminado de editar el archivo, guárdelo y ciérrelo.

      Cree el Ingress en su clúster usando kubectl apply:

      • kubectl apply -f polls-ingress.yaml

      Output

      ingress.networking.k8s.io/polls-ingress created

      Puede usar kubectl describe para rastrear el estado del Ingress que acaba de crear:

      • kubectl describe ingress polls-ingress

      Output

      Name: polls-ingress Namespace: default Address: workaround.your_domain.com Default backend: default-http-backend:80 (<error: endpoints "default-http-backend" not found>) TLS: polls-tls terminates your_domain.com Rules: Host Path Backends ---- ---- -------- your_domain.com polls:8000 (10.244.0.207:8000,10.244.0.53:8000) Annotations: cert-manager.io/cluster-issuer: letsencrypt-staging kubernetes.io/ingress.class: nginx Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal CREATE 51s nginx-ingress-controller Ingress default/polls-ingress Normal CreateCertificate 51s cert-manager Successfully created Certificate "polls-tls" Normal UPDATE 25s nginx-ingress-controller Ingress default/polls-ingress

      También puede ejecutar un describe en el certificado polls-tls para confirmar una vez más que se creó de manera correcta:

      • kubectl describe certificate polls-tls

      Output

      . . . Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Issuing 3m33s cert-manager Issuing certificate as Secret does not exist Normal Generated 3m32s cert-manager Stored new private key in temporary Secret resource "polls-tls-v9lv9" Normal Requested 3m32s cert-manager Created new CertificateRequest resource "polls-tls-drx9c" Normal Issuing 2m58s cert-manager The certificate has been successfully issued

      Esto confirma que el certificado TLS ha sido emitido con éxito y que el cifrado HTTPS ahora está activo para your_domain.com.

      Dado que usamos el ClusterIssuer de ensayo, la mayoría de los navegadores de Internet no confiarán en el certificado Let’s Encrypt que emitió. Por lo tanto, dirigirse a your_domain.com lo llevará a una página de error.

      Para enviar una solicitud de prueba, usaremos wget desde la línea de comandos:

      • wget -O - http://your_domain.com/polls

      Output

      . . . ERROR: cannot verify your_domain.com's certificate, issued by ‘CN=Fake LE Intermediate X1’: Unable to locally verify the issuer's authority. To connect to your_domain.com insecurely, use `--no-check-certificate'.

      Usaremos el indicador --no-check-certificate sugerido para omitir la validación del certificado:

      • wget --no-check-certificate -q -O - http://your_domain.com/polls

      Output

      <link rel="stylesheet" type="text/css" href="https://your_space.nyc3.digitaloceanspaces.com/django-polls/static/polls/style.css"> <p>No polls are available.</p>

      Este resultado muestra el HTML de la página de la interfaz /polls, lo que confirma también que la hoja de estilos se toma desde el almacenamiento de objetos.

      Ahora que probó con éxito la emisión de certificados usando el ClusterIssuer de ensayo, puede modificar el Ingress para usar el ClusterIssuer de producción.

      Abra polls-ingress.yaml para editar una vez más:

      Modifique la anotación cluster-issuer:

      [polls-ingress.yaml]
      apiVersion: networking.k8s.io/v1beta1
      kind: Ingress
      metadata:
        name: polls-ingress
        annotations:
          kubernetes.io/ingress.class: "nginx"
          cert-manager.io/cluster-issuer: "letsencrypt-prod"
      spec:
        tls:
        - hosts:
          - your_domain.com
          secretName: polls-tls
        rules:
        - host: your_domain.com
          http:
            paths:
            - backend:
                serviceName: polls
                servicePort: 8000
      

      Cuando termine, guarde y cierre el archivo. Actualice el Ingress usando kubectl apply:

      • kubectl apply -f polls-ingress.yaml

      Output

      ingress.networking.k8s.io/polls-ingress configured

      Puede usar kubectl describe certificate polls-tls y kubectl describe ingress polls-ingress para rastrear el estado de emisión del certificado:

      • kubectl describe ingress polls-ingress

      Output

      . . . Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal CREATE 23m nginx-ingress-controller Ingress default/polls-ingress Normal CreateCertificate 23m cert-manager Successfully created Certificate "polls-tls" Normal UPDATE 76s (x2 over 22m) nginx-ingress-controller Ingress default/polls-ingress Normal UpdateCertificate 76s cert-manager Successfully updated Certificate "polls-tls"

      El resultado anterior confirma que el nuevo certificado de producción se emitió y almacenó con éxito en el Secret polls-tls.

      Diríjase a your_domain.com/polls en su navegador web para confirmar que el cifrado HTTPS está habilitado y que todo funciona según lo previsto. Debería ver la interfaz de la aplicación Polls:

      Interfaz de la aplicación Polls

      Verifique que el cifrado HTTPS está activo en su navegador web. Si usa Google Chrome, llegar a la página anterior sin errores confirma que todo funciona correctamente. Además, debe ver un candado en la barra de direcciones URL. Al hacer clic en el candado, se le permitirá inspeccionar los detalles del certificado Let’s Encrypt.

      Como tarea de limpieza final, puede cambiar opcionalmente el tipo de servicio polls de NodePort al tipo ClusterIP interno solamente.

      Modifique polls-svc.yaml usando su editor:

      Cambie el type de NodePort a ClusterIP:

      polls-svc.yaml

      apiVersion: v1
      kind: Service
      metadata:
        name: polls
        labels:
          app: polls
      spec:
        type: ClusterIP
        selector:
          app: polls
        ports:
          - port: 8000
            targetPort: 8000
      

      Cuando haya terminado de editar el archivo, guárdelo y ciérrelo.

      Implemente los cambios usando kubectl apply:

      • kubectl apply -f polls-svc.yaml --force

      Output

      service/polls configured

      Confirme que su Service se modificó usando kubectl get svc:

      Output

      NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE polls ClusterIP 10.245.203.186 <none> 8000/TCP 22s

      Este resultado muestra que el tipo de servicio es ahora ClusterIP. La única forma de acceder a él es a través de su dominio y del Ingress creado en este paso.

      Conclusión

      En este tutorial, implementó una aplicación de Django escalable y protegida con HTTPS en un clúster de Kubernetes. El contenido estático se toma directamente desde el almacenamiento de objetos y el número de Pods en ejecución puede aumentar o disminuir rápidamente usando el campo réplicas en el manifiesto de implementación polls-app.

      Si usa un Space de DigitalOcean, también puede habilitar la entrega de activos estáticos a través de una red de entrega de contenido y crear un subdominio personalizado para su Space. Consulte Habilitar CDN en Cómo configurar una aplicación de Django escalable con bases de datos y Spaces administrados por DigitalOcean para obtener más información.

      Para revisar el resto de la serie, visite nuestra página “De contenedores a Kubernetes con Django”.



      Source link

      Cómo usar SFTP para transferir archivos con un servidor remoto de manera segura


      Introducción

      FTP, o “File Transfer Protocol” (Protocolo de transferencia de archivos), era un método popular sin cifrar para transferir archivos entre dos sistemas remotos.

      SFTP, que significa Protocolo de transferencia de archivos SSH o Protocolo de transferencia segura de archivos, es un protocolo independiente empaquetado con SSH que funciona de forma similar pero a través de una conexión segura. La ventaja es la capacidad de aprovechar una conexión segura para transferir archivos y recorrer el sistema de archivos en los sistemas local y remoto.

      En casi todos los casos, es preferible usar SFTP, en vez de FTP, debido a sus características de seguridad subyacentes y a su capacidad para aprovechar una conexión SSH. FTP es un protocolo no seguro que solo debería utilizarse en casos limitados o en redes de confianza.

      Aunque SFTP está integrado en muchas herramientas gráficas, esta guía mostrará cómo utilizarlo en su interfaz de línea de comandos interactiva.

      Cómo conectarse con SFTP

      De forma predeterminada, SFTP utiliza el protocolo SSH para autenticarse y establecer una conexión segura. Por eso, están disponibles los mismos métodos de autenticación que en SSH.

      Aunque las contraseñas son fáciles de usar y se configuran de forma predeterminada, le recomendamos crear claves SSH y transferir su clave pública a cualquier sistema al que necesite acceder. Eso es mucho más seguro y puede ahorrarle tiempo a largo plazo.

      Consulte esta guía para configurar claves SSH para acceder a su servidor si aún no lo hizo.

      Si puede conectarse al equipo usando SSH, habrá completado todos los requisitos necesarios para usar SFTP para administrar archivos. Pruebe el acceso SSH con el siguiente comando:

      • ssh sammy@your_server_ip_or_remote_hostname

      Si esto funciona, salga de nuevo escribiendo:

      Ahora, podemos establecer una sesión SFTP ejecutando el siguiente comando:

      • sftp sammy@your_server_ip_or_remote_hostname

      Conectará el sistema remoto, y la entrada de su línea de comandos cambiará a una instrucción SFTP.

      Si está trabajando en un puerto SSH personalizado (no el puerto 22 predeterminado), puede iniciar una sesión SFTP de la siguiente manera:

      • sftp -oPort=custom_port sammy@your_server_ip_or_remote_hostname

      Eso lo conectará al sistema remoto mediante el puerto especificado.

      Cómo obtener ayuda en SFTP

      El comando más útil que debe conocer primero es el comando help. Este comando le da acceso a un resumen de la ayuda en SFTP. Puede invocarlo escribiendo cualquiera de estos en la instrucción:

      o

      Eso mostrará una lista de los comandos disponibles:

      Output

      Available commands: bye Quit sftp cd path Change remote directory to 'path' chgrp grp path Change group of file 'path' to 'grp' chmod mode path Change permissions of file 'path' to 'mode' chown own path Change owner of file 'path' to 'own' df [-hi] [path] Display statistics for current directory or filesystem containing 'path' exit Quit sftp get [-Ppr] remote [local] Download file help Display this help text lcd path Change local directory to 'path' . . .

      En las siguientes secciones, exploraremos algunos de los comandos que verá.

      Cómo navegar con SFTP

      Podemos navegar a través de la jerarquía de archivos del sistema remoto usando varios comandos que funcionan de forma similar a sus contrapartes de shell.

      Primero, orientémonos averiguando en qué directorio estamos actualmente en el sistema remoto. Al igual que en una sesión típica de shell, podemos escribir lo siguiente para obtener el directorio actual:

      Output

      Remote working directory: /home/demouser

      Podemos ver el contenido del directorio actual del sistema remoto con otro comando familiar:

      Output

      Summary.txt info.html temp.txt testDirectory

      Tenga en cuenta que los comandos en la interfaz SFTP no son los comandos de shell normales y no cuentan con la misma cantidad de funciones, pero implementan algunos de los indicadores opcionales más importantes:

      Output

      drwxr-xr-x 5 demouser demouser 4096 Aug 13 15:11 . drwxr-xr-x 3 root root 4096 Aug 13 15:02 .. -rw------- 1 demouser demouser 5 Aug 13 15:04 .bash_history -rw-r--r-- 1 demouser demouser 220 Aug 13 15:02 .bash_logout -rw-r--r-- 1 demouser demouser 3486 Aug 13 15:02 .bashrc drwx------ 2 demouser demouser 4096 Aug 13 15:04 .cache -rw-r--r-- 1 demouser demouser 675 Aug 13 15:02 .profile . . .

      Para llegar a otro directorio, podemos ejecutar este comando:

      Ahora, podemos recorrer el sistema de archivos remotos, pero ¿qué pasa si necesitamos acceder a nuestro sistema de archivos local? Podemos dirigir los comandos al sistema de archivos locales precediéndolos con una l que hace referencia a “local”.

      Todos los comandos examinados hasta ahora tienen equivalentes locales. Podemos imprimir el directorio local de trabajo:

      Output

      Local working directory: /Users/demouser

      Podemos enumerar el contenido del directorio actual en el equipo local:

      Output

      Desktop local.txt test.html Documents analysis.rtf zebra.html

      También podemos cambiar el directorio con el que deseamos interactuar en el sistema local:

      Cómo transferir archivos con SFTP

      Navegar por los sistemas de archivos locales y remotos es muy poco útil si no se puede transferir archivos entre ambos.

      Transferencia de archivos remotos al sistema local

      Si queremos descargar archivos de nuestro host remoto, podemos hacerlo ejecutando el siguiente comando:

      Output

      Fetching /home/demouser/remoteFile to remoteFile /home/demouser/remoteFile 100% 37KB 36.8KB/s 00:01

      Como puede ver, de forma predeterminada, el comando get descarga un archivo remoto a un archivo con el mismo nombre en el sistema de archivos locales.

      Podemos copiar el archivo remoto a un nombre diferente especificando el nombre después:

      El comando get también toma algunos indicadores de opción. Por ejemplo, podemos copiar un directorio y todo su contenido especificando la opción recursiva:

      Podemos indicarle a SFTP que mantenga los permisos y los tiempos de acceso adecuados utilizando el indicador -P o -p:

      Transferencia de archivos locales al sistema remoto

      Transferir archivos al sistema remoto es tan fácil como utilizar el comando correctamente llamado “put”:

      Output

      Uploading localFile to /home/demouser/localFile localFile 100% 7607 7.4KB/s 00:00

      Los mismos indicadores que funcionan con get se aplican a put. Para copiar un directorio local completo, puede ejecutar:

      Nota: Actualmente, hay un error en las versiones de OpenSSH incluidas en las versiones actuales de Ubuntu (al menos de la versión 14.04 a la 15.10) que impide que el comando anterior funcione correctamente. Cuando se ejecuta el comando anterior para transferir contenido a un servidor utilizando la versión con errores de OpenSSH, se producirá el siguiente error: Couldn't canonicalise: No such file or directory (No se pudo canonizar: no existe tal archivo o directorio).

      Para resolver este problema, primero cree el directorio de destino en el extremo remoto escribiendo mkdir localDirectory. Luego, el comando anterior debería completarse sin errores.

      Una herramienta familiar que es útil para descargar y cargar archivos es el comando df, que funciona de forma similar a la versión de la línea de comandos. Al utilizarla, puede verificar que tiene suficiente espacio para completar las transferencias que le interesan:

      Output

      Size Used Avail (root) %Capacity 19.9GB 1016MB 17.9GB 18.9GB 4%

      Tenga en cuenta que no hay ninguna variación local de este comando, pero podemos solucionarlo ejecutando ! como comando.

      El comando ! nos lleva a un shell local, donde podemos ejecutar cualquier comando disponible en nuestro sistema local. Podemos verificar el uso del disco escribiendo lo siguiente:

      y luego

      Output

      Filesystem Size Used Avail Capacity Mounted on /dev/disk0s2 595Gi 52Gi 544Gi 9% / devfs 181Ki 181Ki 0Bi 100% /dev map -hosts 0Bi 0Bi 0Bi 100% /net map auto_home 0Bi 0Bi 0Bi 100% /home

      Cualquier otro comando local funcionará de la manera esperada. Para volver a su sesión SFTP, escriba lo siguiente:

      Ahora, debería ver el retorno de la instrucción de SFTP.

      Manipulaciones de archivos simples con SFTP

      SFTP le permite realizar el tipo de mantenimiento básico de archivos que es útil cuando se trabaja con jerarquías de archivos.

      Por ejemplo, puede cambiar el propietario de un archivo en el sistema remoto con:

      Observe cómo, a diferencia del comando chmod del sistema, el comando SFTP no acepta nombres de usuario, sino que utiliza UID. Lamentablemente, no hay una manera sencilla de saber el UID adecuado desde la interfaz SFTP.

      Se puede realizar una solución alternativa más compleja con:

      • get /etc/passwd
      • !less passwd

      Output

      root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/bin/sh bin:x:2:2:bin:/bin:/bin/sh sys:x:3:3:sys:/dev:/bin/sh sync:x:4:65534:sync:/bin:/bin/sync games:x:5:60:games:/usr/games:/bin/sh man:x:6:12:man:/var/cache/man:/bin/sh . . .

      Observe cómo en vez de utilizar el comando ! en sí, lo utilizamos como prefijo para un comando de shell local. Eso funciona para ejecutar cualquier comando disponible en nuestro equipo local y podría haberse utilizado anteriormente con el comando local df.

      El UID se encuentra en la tercera columna del archivo, delimitado por caracteres de dos puntos.

      De manera similar, podemos cambiar el propietario del grupo de un archivo con:

      De nuevo, no existe una forma sencilla de obtener una lista de los grupos del sistema remoto. Podemos solucionarlo con el siguiente comando:

      • get /etc/group
      • !less group

      Output

      root:x:0: daemon:x:1: bin:x:2: sys:x:3: adm:x:4: tty:x:5: disk:x:6: lp:x:7: . . .

      La tercera columna contiene el ID del grupo asociado con el nombre en la primera columna. Eso es lo que buscamos.

      Por suerte, el comando chmod funciona correctamente en el sistema de archivos remotos:

      Output

      Changing mode on /home/demouser/publicFile

      No existe ningún comando para manipular permisos de archivo locales, pero puede quitar la máscara local para que todos los archivos que se copien al sistema local tengan los permisos adecuados.

      Eso se puede lograr con el comando lumask:

      Output

      Local umask: 022

      Ahora, todos los archivos regulares descargados (siempre que no se utilice el indicador -p) tendrán 644 permisos.

      SFTP permite crear directorios en sistemas locales y en sistemas remotos con lmkdir y mkdir, respectivamente. Estos funcionan de la manera prevista.

      El resto de los comandos del archivo solo apuntan al sistema de archivos remotos:

      Estos comandos replican el comportamiento básico de las versiones del shell. Si necesita realizar estas acciones en el sistema de archivos local, recuerde que puede ingresar a un shell ejecutando este comando:

      O ejecutar un comando único en el sistema local anteponiendo ! al comando de esta manera:

      Cuando termine con la sesión SFTP, utilice exit o bye para cerrar la conexión.

      Conclusión

      Aunque SFTP es una herramienta simple, es muy útil para administrar servidores y transferir archivos entre ellos.

      Por ejemplo, puede usar SFTP para permitir que determinados usuarios transfieran archivos sin acceso SSH. Para obtener más información sobre este proceso, consulte nuestro tutorial Cómo habilitar SFTP sin acceso de shell.

      Si está acostumbrado a utilizar FTP o SCP para realizar sus transferencias, SFTP es una buena forma de aprovechar las ventajas de ambos. Si bien no es adecuado para todas las situaciones, es útil tenerlo en su repertorio por ser una herramienta flexible.



      Source link

      Cómo instalar y configurar Zabbix para monitorizar servidores remotos de forma segura en Ubuntu 20.04


      El autor seleccionó el Computer History Museum para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Zabbix es un software de monitorización de código abierto para redes y aplicaciones. Ofrece monitorización en tiempo real de miles de métricas recogidas de servidores, equipos virtuales, dispositivos de red y aplicaciones web. Estas métricas pueden ayudarle a determinar el estado actual de su infraestructura TI y a detectar problemas con los componentes de hardware o software antes de que los clientes se quejen. La información útil se almacena en una base de datos para que pueda analizar datos a lo largo del tiempo y mejorar la calidad de los servicios proporcionados o planificar mejoras de su equipo.

      Zabbix usa varias opciones para recoger métricas, incluyendo la monitorización sin agente de los servicios del usuario y de la arquitectura cliente-servidor. Para recoger métricas del servidor, utiliza un agente pequeño en el cliente monitorizado para recopilar datos y enviarlos al servidor Zabbix. Zabbix admite la comunicación cifrada entre el servidor y los clientes conectados, de forma que sus datos están protegidos mientras recorren redes inseguras.

      El servidor Zabbix almacena sus datos en una base de datos relacional alimentada con MySQL o PostgreSQL. También puede almacenar datos históricos en bases de datos NoSQL como Elasticsearch y TimescaleDB. Zabbix ofrece una interfaz web para que pueda ver los datos y configurar los ajustes del sistema.

      En este tutorial, configurará Zabbix en dos equipos Ubuntu 20.04. Uno será configurado como el servidor Zabbix y el otro como un cliente que monitorizará. El servidor Zabbix usará una base de datos MySQL para registrar los datos de monitorización y utilizará Nginx para presentar la interfaz web.

      Requisitos previos

      Para seguir este tutorial, necesitará lo siguiente:

      • Dos servidores de Ubuntu 20.04 configurado siguiendo la Guía de configuración inicial del servidor para Ubuntu 20.04, que incluye un usuario no root con privilegios sudo y un firewall configurado con ufw. En un servidor, instalará Zabbix; este tutorial lo llamará servidor Zabbix. Monitorizará su segundo servidor; este segundo servidor se llamará segundo servidor Ubuntu.

      • El servidor que ejecutará el servidor Zabbix necesita tener instalados Nginx, MySQL y PHP. Siga los pasos 1 a 3 de nuestra guía Pila LEMP en Ubuntu 20.04 para configurarlos en su servidor Zabbix.

      • Un nombre de dominio registrado. Para este tutorial, se utilizará your_domain en todo momento. Puede adquirir un nombre de dominio en Namecheap, obtener uno gratuito en Freenom o utilizar un registrador de dominios de su elección.

      • Los dos registros DNS que se indican a continuación se han configurado para su servidor Zabbix. Si está usando DigitalOcean, consulte nuestra documentación DNS para obtener más información sobre cómo añadirlos.

        • Un registro A con your_domain orientado a la dirección IP pública de su servidor Zabbix.
        • Un registro A con www.your_domain orientado a la dirección IP pública de su servidor Zabbix.

      Además, debido a que el Servidor Zabbix se usa para acceder a información valiosa sobre su servidor a la que no quiere que accedan usuarios no autorizados, es importante que mantenga su servidor protegido instalando un certificado TLS o SSL. Esto es opcional, pero se recomienda encarecidamente. Si desea proteger su servidor, siga la guía sobre Let´s Encrypt en Ubuntu 20.04 tras el paso 3 de este tutorial.

      Paso 1: Instalar el servidor Zabbix

      Primero, debe instalar Zabbix en el servidor donde instaló MySQL, Nginx y PHP. Inicie sesión en este equipo como su usuario no root:

      • ssh sammy@zabbix_server_ip_address

      Zabbix está disponible en el administrador de paquetes de Ubuntu, pero está obsoleto, de forma que utilice el repositorio oficial de Zabbix para instalar la última versión estable. Descargue e instale el paquete de configuración del repositorio:

      • wget https://repo.zabbix.com/zabbix/5.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_5.0-1+focal_all.deb
      • sudo dpkg -i zabbix-release_5.0-1+focal_all.deb

      Verá lo siguiente:

      Output

      Selecting previously unselected package zabbix-release. (Reading database ... 64058 files and directories currently installed.) Preparing to unpack zabbix-release_5.0-1+focal_all.deb ... Unpacking zabbix-release (1:5.0-1+focal) ... Setting up zabbix-release (1:5.0-1+focal) ...

      Actualice el índice del paquete para que se incluya el nuevo repositorio:

      A continuación, instale el servidor Zabbix y el frontend web con el soporte de la base de datos de MySQL:

      • sudo apt install zabbix-server-mysql zabbix-frontend-php

      Instale también el agente Zabbix, que le permitirá recoger datos sobre el estado del servidor Zabbix.

      • sudo apt install zabbix-agent

      Antes de poder usar Zabbix, tendrá que configurar una base de datos para albergar los datos que el servidor Zabbix recogerá de sus agentes. Puede hacer esto en el siguiente paso.

      Paso 2: Configurar la base de datos MySQL para Zabbix

      Deberá crear una nueva base de datos MySQL y completarla con cierta información básica para hacer que sea adecuada para Zabbix. También creará un usuario específico para esta base de datos de forma que Zabbix no esté iniciando sesión en MySQL con la cuenta root.

      Inicie sesión en MySQL como el usuario root:

      Cree la base de datos Zabbix con compatibilidad de caracteres UTF-8:

      • create database zabbix character set utf8 collate utf8_bin;

      A continuación cree un usuario que el servidor Zabbix usará, proporciónele acceso a la nueva base de datos y establezca la contraseña para el usuario.

      • create user zabbix@localhost identified by 'your_zabbix_mysql_password';
      • grant all privileges on zabbix.* to zabbix@localhost;

      Con esto tendremos el usuario y la base de datos. Salga de la consola de la base de datos.

      A continuación, tendrá que importar el esquema inicial y los datos. La instalación de Zabbix le proporcionó un archivo que configura esto.

      Ejecute el siguiente comando para configurar el esquema e importar los datos a la base de datos zabbix. Utilice zcat ya que los datos en el archivo están comprimidos:

      • zcat /usr/share/doc/zabbix-server-mysql*/create.sql.gz | mysql -uzabbix -p zabbix

      Introduzca la contraseña para el usuario MySQL zabbix que configuró cuando se le pida.

      Este comando puede tardar un minuto o dos en ejecutarse. Si ve el error ERROR 1045 (28000): Access denied for userzabbix@'localhost' (using password: YES), asegúrese de usar la contraseña adecuada para el usuario zabbix.

      Para que el servidor Zabbix utilice esta base de datos, deberá establecer la contraseña de la base de datos en el archivo de configuración del servidor Zabbix. Abra el archivo de configuración en su editor de texto preferido: En este tutorial, se usará nano:

      • sudo nano /etc/zabbix/zabbix_server.conf

      Busque la siguiente sección del archivo:

      /etc/zabbix/zabbix_server.conf

      ...
      ### Option: DBPassword                           
      #       Database password. Ignored for SQLite.   
      #       Comment this line if no password is used.
      #                                                
      # Mandatory: no                                  
      # Default:                                       
      # DBPassword=
      ...
      

      Estos comentarios en el archivo explican cómo conectar con la base de datos. Deberá establecer el valor DBPassword en el archivo a la contraseña para su usuario de la base de datos. Añada esta línea tras esos comentarios para configurar la base de datos:

      /etc/zabbix/zabbix_server.conf

      ...
      DBPassword=your_zabbix_mysql_password
      ...
      

      Guarde y cierre zabbix_server.conf pulsando CTRL+X, seguido de Y y ENTER si está usando nano.

      Ahora ha configurado el servidor Zabbix para que se conecte a la base de datos. A continuación, configurará el servidor web Nginx para presentar el frontend de Zabbix.

      Paso 3: Configurar Nginx para Zabbix

      Para configurar Nginx de forma automática, instale el paquete de configuración automática:

      • sudo apt install zabbix-nginx-conf

      Como resultado, obtendrá el archivo de configuración /etc/zabbix/nginx.conf, así como un enlace a él en el directorio de configuración de Nginx /etc/zabbix/nginx.conf.

      A continuación, debe realizar cambios a este archivo. Abra el archivo de configuración:

      • sudo nano /etc/zabbix/nginx.conf

      El archivo contiene una configuración del bloque de servidor Nginx generada automáticamente. Contiene dos líneas que determinan el nombre del servidor y el puerto en el que está escuchando:

      /etc/zabbix/nginx.conf

      server {
      #        listen          80;
      #        server_name     example.com;
      ...
      

      Borre las dos líneas y sustituya example.com con su nombre de dominio. Sus ajustes tendrán este aspecto:

      /etc/zabbix/nginx.conf

      server {
              listen          80;
              server_name     your_domain;
      ...
      

      Guarde y cierre el archivo. A continuación, compruebe que no haya errores de sintaxis en ninguno de sus archivos de Nginx y vuelva a cargar la configuración:

      • sudo nginx -t
      • sudo nginx -s reload

      Ahora que Nginx está configurado para presentar el frontend de Zabbix, realizará algunas modificaciones a su configuración PHP para que la interfaz web de Zabbix funcione correctamente.

      Nota: Como se indica en la sección de requisitos previos, se le recomienda habilitar SSL o TLS en su servidor. Si desea hacer esto, siga nuestro tutorial de Let´s Encrypt para Ubuntu 20.04 antes de pasar al Paso 4 para obtener un certificado gratuito SSL para Nginx. Este proceso detectará automáticamente el bloque de servidores Zabbix y lo configurará para HTTPS. Una vez que obtenga sus certificados SSL y TLS, puede volver y completar este tutorial.

      Paso 4: Configurar PHP para Zabbix

      La interfaz web Zabbix se escribe en PHP y requiere algunos ajustes especiales del servidor PHP. El proceso de instalación de Zabbix creó un archivo de configuración PHP-FPM que contiene estos ajustes. Está ubicado en el directorio /etc/zabbix y PHP-FPM lo carga automáticamente. Deberá realizar un pequeño cambio a este archivo, de forma que ábralo con lo siguiente:

      • sudo nano /etc/zabbix/php-fpm.conf

      El archivo contiene los ajustes PHP que cumplen con los requisitos necesarios para la interfaz web de Zabbix. Sin embargo, el ajuste de zona horaria está eliminado por defecto. Para asegurar que Zabbix utiliza la hora correcta, deberá establecer la zona horaria apropiada:

      /etc/zabbix/php-fpm.conf

      ...
      php_value[max_execution_time] = 300
      php_value[memory_limit] = 128M
      php_value[post_max_size] = 16M
      php_value[upload_max_filesize] = 2M
      php_value[max_input_time] = 300
      php_value[max_input_vars] = 10000
      ; php_value[date.timezone] = Europe/Riga
      

      Borre la línea timezone resaltada en el bloque de código anterior y cámbiela a su zona horaria. Puede usar esta lista de zonas horarias compatibles para encontrar la adecuada para usted. Luego, guarde y cierre el archivo.

      Ahora reinicie PHP-FPM para aplicar esta nueva configuración:

      • sudo systemctl restart php7.4-fpm.service

      Ahora puede iniciar el servidor Zabbix:

      • sudo systemctl start zabbix-server

      A continuación, compruebe si el servidor Zabbix está funcionando correctamente:

      • sudo systemctl status zabbix-server

      Verá el siguiente estado:

      Output

      ● zabbix-server.service - Zabbix Server Loaded: loaded (/lib/systemd/system/zabbix-server.service; disabled; vendor preset: enabled) Active: active (running) since Fri 2020-06-12 05:59:32 UTC; 36s ago Process: 27026 ExecStart=/usr/sbin/zabbix_server -c $CONFFILE (code=exited, status=0/SUCCESS) ...

      Finalmente, habilite el servidor para que se inicie en el momento del arranque:

      • sudo systemctl enable zabbix-server

      El servidor está configurado y conectado a la base de datos. A continuación, configure el frontend web.

      Paso 5: Configurar los ajustes de la interfaz web de Zabbix

      La interfaz web le permite ver los informes y añadir los hosts que desea monitorizar, pero necesita cierta configuración inicial antes de poder usarla. Abra su servidor y vaya a la dirección http://zabbix_server_name o https://zabbix_server_name si configuró Let´s Encrypt. En la primera pantalla, verá un mensaje de bienvenida. Haga clic en Siguiente paso para continuar.

      En la siguiente pantalla, verá la tabla que enumera todos los requisitos previos para ejecutar Zabbix.

      Requisitos previos

      Todos los valores de esta tabla deben estar en OK, de forma que verifique que así es. Asegúrese de desplazarse hacia abajo y ver todos los requisitos previos. Una vez que haya verificado que todo está listo, haga clic en Siguiente paso para continuar.

      La siguiente pantalla pide información sobre la conexión con la base de datos.

      Conexión con la BBDD

      Le ha hablado al servidor Zabbix sobre su base de datos, pero la interfaz web de Zabbix también necesita acceder a la base de datos para administrar los hosts y leer datos. Por tanto, introduzca las credenciales de MySQL que configuró en el Paso 2. Haga clic en Siguiente paso para continuar.

      En la siguiente pantalla, puede dejar las opciones en sus valores predeterminados.

      Detalles del servidor Zabbix

      El Nombre es opcional; se usa en la interfaz web para distinguir un servidor de otro en caso de que tenga varios servidores de monitorización. Haga clic en Siguiente paso para continuar.

      La siguiente pantalla mostrará el resumen de la preinstalación para que pueda confirmar que todo es correcto.

      Resumen

      Haga clic en Siguiente paso para continuar a la pantalla final.

      Ha finalizado la configuración de la interfaz web. Este proceso crea el archivo de configuración /usr/share/zabbix/conf/zabbix.conf.php, del que podría realizar copias de seguridad para su uso en el futuro. Haga clic en Finalizar para continuar a la pantalla de inicio de sesión. El usuario predeterminado es Admin y la contraseña es zabbix.

      Antes de iniciar sesión, configure el agente Zabbix en su segundo servidor Ubuntu.

      Paso 6: Instalar y configurar el agente Zabbix

      Ahora, deberá configurar el software agente que enviará datos de monitorización al servidor Zabbix.

      Inicie sesión en el segundo servidor Ubuntu:

      • ssh sammy@second_ubuntu_server_ip_address

      Al igual que en el servidor Zabbix, ejecute los siguientes comandos para instalar el paquete de configuración del repositorio:

      • wget https://repo.zabbix.com/zabbix/5.0/ubuntu/pool/main/z/zabbix-release/zabbix-release_5.0-1+focal_all.deb
      • sudo dpkg -i zabbix-release_5.0-1+focal_all.deb

      A continuación, actualice el índice del paquete:

      Luego instale el agente Zabbix:

      • sudo apt install zabbix-agent

      Aunque Zabbix es compatible con el cifrado basado en certificados, configurar una autoridad de certificado está fuera del ámbito de este tutorial. Pero puede usar claves precompartidas (PSK) para proteger la conexión entre el servidor y el agente.

      Primero, genere una PSK:

      • sudo sh -c "openssl rand -hex 32 > /etc/zabbix/zabbix_agentd.psk"

      Muestre la clave usando cat para que pueda copiarla en otra parte:

      • cat /etc/zabbix/zabbix_agentd.psk

      La clave tendrá un aspecto similar a este:

      Output

      75ad6cb5e17d244ac8c00c96a1b074d0550b8e7b15d0ab3cde60cd79af280fca

      Guarde esto para más tarde; la necesitará para configurar el host.

      Ahora edite los ajustes del agente Zabbix para configurar su conexión segura al servidor Zabbix. Abra el archivo de configuración en su editor de texto:

      • sudo nano /etc/zabbix/zabbix_agentd.conf

      Cada ajuste en este archivo se documenta a través de comentarios informativos por todo el archivo, pero solo necesitará editar algunos de ellos.

      Primero tendrá que editar la dirección IP del servidor Zabbix. Busque la siguiente sección:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: Server
      #       List of comma delimited IP addresses, optionally in CIDR notation, or DNS names of Zabbix servers and Zabbix proxies.
      #       Incoming connections will be accepted only from the hosts listed here.
      #       If IPv6 support is enabled then '127.0.0.1', '::127.0.0.1', '::ffff:127.0.0.1' are treated equally
      #       and '::/0' will allow any IPv4 or IPv6 address.
      #       '0.0.0.0/0' can be used to allow any IPv4 address.
      #       Example: Server=127.0.0.1,192.168.1.0/24,::1,2001:db8::/32,zabbix.example.com
      #
      # Mandatory: yes, if StartAgents is not explicitly set to 0
      # Default:
      # Server=
      
      Server=127.0.0.1
      ...
      

      Cambie el valor predeterminado a la IP de su servidor Zabbix:

      /etc/zabbix/zabbix_agentd.conf

      ...
      Server=zabbix_server_ip_address
      ...
      

      Por defecto, el servidor Zabbix se conecta con el agente. Pero para algunas comprobaciones (por ejemplo, monitorizar los registros), se requiere una conexión inversa. Para obtener un funcionamiento correcto, deberá especificar la dirección del servidor Zabbix y un nombre de host único.

      Busque la sección que configura las comprobaciones activas y cambie los valores predeterminados:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ##### Active checks related
      
      ### Option: ServerActive
      #       List of comma delimited IP:port (or DNS name:port) pairs of Zabbix servers and Zabbix proxies for active checks.
      #       If port is not specified, default port is used.
      #       IPv6 addresses must be enclosed in square brackets if port for that host is specified.
      #       If port is not specified, square brackets for IPv6 addresses are optional.
      #       If this parameter is not specified, active checks are disabled.
      #       Example: ServerActive=127.0.0.1:20051,zabbix.domain,[::1]:30051,::1,[12fc::1]
      #
      # Mandatory: no
      # Default:
      # ServerActive=
      
      ServerActive=zabbix_server_ip_address
      
      ### Option: Hostname
      #       Unique, case sensitive hostname.
      #       Required for active checks and must match hostname as configured on the server.
      #       Value is acquired from HostnameItem if undefined.
      #
      # Mandatory: no
      # Default:
      # Hostname=
      
      Hostname=Second Ubuntu Server
      ...
      

      A continuación, busque la sección que configura la conexión segura con el servidor Zabbix y habilite el soporte con clave precompartida. Busque la sección TLSConnect, que tiene el siguiente aspecto:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSConnect
      #       How the agent should connect to server or proxy. Used for active checks.
      #       Only one value can be specified:
      #               unencrypted - connect without encryption
      #               psk         - connect using TLS and a pre-shared key
      #               cert        - connect using TLS and a certificate
      #
      # Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection)
      # Default:
      # TLSConnect=unencrypted
      ...
      

      A continuación añada esta línea para configurar el soporte de clave precompartida:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSConnect=psk
      ...
      

      Luego, localice la sección TLSAccept, que tiene el siguiente aspecto:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSAccept
      #       What incoming connections to accept.
      #       Multiple values can be specified, separated by comma:
      #               unencrypted - accept connections without encryption
      #               psk         - accept connections secured with TLS and a pre-shared key
      #               cert        - accept connections secured with TLS and a certificate
      #
      # Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection)
      # Default:
      # TLSAccept=unencrypted
      ...
      

      Configure las conexiones entrantes para que admitan las claves precompartidas añadiendo esta línea:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSAccept=psk
      ...
      

      Luego, localice la sección TLSPSKIdentity, que tiene el siguiente aspecto:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSPSKIdentity
      #       Unique, case sensitive string used to identify the pre-shared key.
      #
      # Mandatory: no
      # Default:
      # TLSPSKIdentity=
      ...
      

      Elija un nombre único para identificar su clave precompartida añadiendo esta línea:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSPSKIdentity=PSK 001
      ...
      

      Usará esto como el PSK ID cuando añada su host a través de la interfaz web de Zabbix.

      A continuación establezca la opción que apunta a su clave precompartida creada previamente. Busque la opción TLSPSKFile:

      /etc/zabbix/zabbix_agentd.conf

      ...
      ### Option: TLSPSKFile
      #       Full pathname of a file containing the pre-shared key.
      #
      # Mandatory: no
      # Default:
      # TLSPSKFile=
      ...
      

      Añada esta línea para apuntar el agente Zabbix al archivo PSK que ha creado:

      /etc/zabbix/zabbix_agentd.conf

      ...
      TLSPSKFile=/etc/zabbix/zabbix_agentd.psk
      ...
      

      Guarde y cierre el archivo. Ahora puede reiniciar el agente Zabbix y configurarlo para que se inicie en el arranque:

      • sudo systemctl restart zabbix-agent
      • sudo systemctl enable zabbix-agent

      Por seguridad, compruebe que el agente Zabbix se está ejecutando correctamente:

      • sudo systemctl status zabbix-agent

      Verá el siguiente estado, que indica que el agente se está ejecutando:

      Output

      ● zabbix-agent.service - Zabbix Agent Loaded: loaded (/lib/systemd/system/zabbix-agent.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2020-06-12 08:19:54 UTC; 25s ago ...

      El agente escuchará en el puerto 10050 las conexiones del servidor. Configure UFW para permita las conexiones con este puerto:

      Puede obtener más información sobre UFW en Cómo configurar un firewall con UFW en Ubuntu 20.04.

      Su agente está listo para enviar datos al servidor Zabbix. Pero para usarlo, tendrá que vincularlo desde la consola web del servidor. En el siguiente paso, completará la configuración.

      Paso 7: Añadir el nuevo host al servidor Zabbix

      Instalar un agente en un servidor que desea monitorizar es solo la mitad del proceso. Cada host que desee monitorizar debe estar registrado en el servidor Zabbix, lo cual puede hacer a través de la interfaz web.

      Inicie sesión en la interfaz web del servidor Zabbix navegando a la dirección http://zabbix_server_name o https://zabbix_server_name:

      La pantalla de inicio de sesión de Zabbix

      Cuando haya iniciado sesión, haga clic en Configuración y, luego, en Hosts en la barra de navegación izquierda. A continuación haga clic en el botón Crear host en la esquina superior derecha de la pantalla. Esto abrirá la página de configuración del host.

      Crear un host

      Ajuste el Nombre del host y la Dirección IP para reflejar el nombre de host y la dirección IP de su segundo servidor Ubuntu y luego añada el host a un grupo. Puede seleccionar un grupo existente, por ejemplo Servidores Linux o crear su propio grupo. El host puede estar en varios grupos. Para hacer esto, introduzca el nombre de un grupo existente o uno nuevo en el campo Grupos y seleccione el valor deseado de la lista propuesta.

      Antes de añadir el grupo, haga clic en la pestaña Plantillas.

      Añadir una plantilla al host

      Escriba Template OS Linux by Zabbix agent en el campo Buscar y selecciónela de la lista para añadir esta plantilla al host.

      A continuación, navegue a la pestaña Cifrado. Seleccione PSK para Conexiones al host y Conexiones desde el host. A continuación, establezca la identidad PSK a PSK 001, que es el valor del ajuste TLSPSKIdentity del agente Zabbix que configuró previamente. Ahora configure el valor PSK a la clave que generó para el agente Zabbix. Es la almacenada en el archivo /etc/zabbix/zabbix_agentd.psk en el equipo agente.

      Configurar el cifrado

      Finalmente, haga clic en el botón Añadir en la parte inferior del formulario para crear el host.

      Verá su nuevo host en la lista. Espere un minuto y vuelva a cargar la página para ver etiquetas verdes que indican que todo funciona bien y la conexión está cifrada.

      Zabbix muestra su nuevo host

      Si tiene servidores adicionales que desea monitorizar, inicie sesión en cada host, instale el agente Zabbix, genere una PSK, configure el agente y añada el host a la interfaz web siguiendo los mismos pasos que siguió para añadir su primer host.

      El servidor Zabbix está ahora monitorizando su segundo servidor Ubuntu. Ahora, configure notificaciones por correo electrónico para recibir avisos sobre problemas.

      Paso 8: Configurar notificaciones por correo electrónico

      Zabbix admite automáticamente muchos tipos de notificaciones: correo electrónico, OTRS, Slack, Telegram, SMS, etc. Puede ver la lista completa de integraciones en el sitio web de Zabbix.

      Como ejemplo, este tutorial configurará notificaciones para el tipo de medio Correo electrónico.

      Haga clic en Administración, y a continuación en Tipos de medio en la barra de navegación izquierda. Verá la lista de todos los tipos de medios. Existen dos opciones preconfiguradas para correos electrónicos: para la notificación de texto sin formato y para las notificaciones HTML. En este tutorial, usará la notificación de texto sin formato. Haga clic en Correo electrónico.

      Ajuste las opciones SMTP según los ajustes proporcionados por su servicio de correo electrónico. Este tutorial utiliza las capacidades SMTP de Gmail para configurar las notificaciones por correo electrónico; si desea obtener más información sobre cómo configurar esto, consulte Cómo usar el servicio SMTP de Google.

      Nota: Si utiliza la Verificación de 2 pasos con Gmail, deberá generar una contraseña de aplicación para Zabbix. Solo tendrá que introducir una contraseña de aplicación una vez durante la configuración. Encontrará instrucciones sobre cómo generar esta contraseña en el Centro de Ayuda de Google.

      Si está usando Gmail, escriba smtp.gmail.com para el campo Servidor SMTP, 465 para el campo Puerto del servidor SMTP, gmail.com para SMTP helo, y su correo electrónico para Correo electrónico SMTP. Luego seleccione SSL/TLS para Seguridad de la conexión y Nombre de usuario y contraseña para Autenticación. Introduzca su dirección de Gmail como el Nombre de usuario, y la Contraseña de aplicación que generó desde su cuenta de Google como Contraseña.

      Configurar el tipo de medio de correo electrónico

      En la pestaña Plantillas de mensaje, puede ver la lista de mensajes predefinidos para varios tipos de notificaciones. Finalmente, haga clic en el botón Actualizar en la parte inferior del formulario para actualizar los parámetros del correo electrónico.

      Ahora puede probar el envío de notificaciones. Para hacer esto, haga clic en el enlace subrayado Prueba en la línea correspondiente.

      Ahora verá una ventana emergente. Introduzca su dirección de correo electrónico en el campo Enviar a *y haga clic en el botón *Prueba. Verá un mensaje sobre el envío correcto y recibirá un mensaje de prueba.

      Correo electrónico de prueba

      Cierre la ventana emergente haciendo clic en el botón Cancelar.

      Ahora cree un nuevo usuario. Haga clic en Administración y, a continuación, en** Usuarios** en la barra de navegación izquierda. Verá la lista de usuarios. A continuación haga clic en el botón Crear usuario en la esquina superior derecha de la pantalla. Esto abrir la página de configuración del usuario:

      Crear un usuario

      Introduzca el nuevo nombre de usuario en el campo Alias y configure una nueva contraseña. A continuación, añada el usuario al grupo del administrador. Escriba Zabbix administrators en el campo Grupos y selecciónelo desde la lista propuesta.

      Una vez que haya añadido el grupo, haga clic en la pestaña Medios y haga clic en el enlace subrayado Añadir (no el botón Añadir debajo). Ahora verá una ventana emergente.

      Añadir un correo electrónico

      Seleccione la opción Correo electrónico desde el desplegable Tipo. Introduzca su dirección de correo en el campo Enviar a. Puede dejar el resto de las opciones en sus valores predeterminados. Haga clic en el botón Añadir en la parte inferior para enviar.

      Ahora navegue a la pestaña Permisos. Seleccione Zabbix Super Admin desde el menú desplegable Tipo de usuario.

      Finalmente, haga clic en el botón Añadir en la parte inferior del formulario para crear el usuario.

      Nota: Usar la contraseña predeterminada no es seguro. Para cambiar la contraseña del usuario integrado Admin, haga clic en el alias en la lista de usuarios. Luego haga clic en Cambiar contraseña, introduzca una nueva contraseña y confirme los cambios haciendo clic en el botón Actualizar.

      Ahora debe habilitar las notificaciones. Haga clic en la pestaña Configuración y a continuación en Acciones en la barra de navegación izquierda. Verá una acción preconfigurada, que es responsable de enviar notificaciones a todos los administradores Zabbix. Puede revisar y cambiar los ajustes haciendo clic en su nombre. A efectos de este tutorial, utilice los parámetros predeterminados. Para habilitar la acción, haga clic en el enlace rojo Deshabilitado en la columna Estado.

      Ahora está listo para recibir alertas. En el siguiente paso, generará una para probar la configuración de notificaciones.

      Paso 9: Generar una alerta de prueba

      En este paso, generará una alerta de prueba para garantizar que todo está conectado. Por defecto, Zabbix realiza un seguimiento de la cantidad de espacio libre en el disco de su servidor. Detecta automáticamente todos los montajes en disco y añade las comprobaciones correspondientes. Este descubrimiento se ejecuta cada hora, de forma que deberá esperar un poco para que se active la notificación.

      Cree un archivo temporal que sea lo suficientemente grande para activar la alerta de uso del sistema de archivos de Zabbix. Para hacer esto, inicie sesión en su segundo servidor Ubuntu si aún no está conectado:

      • ssh sammy@second_ubuntu_server_ip_address

      A continuación, determine cuánto espacio libre tiene en el servidor. Puede usar el comando df para averiguarlo:

      El comando df informará del uso del espacio en el disco de su sistema de archivos, y -h hará que el resultado sea legible para el ser humano. Verá un resultado como el siguiente:

      Output

      Filesystem Size Used Avail Use% Mounted on /dev/vda1 78G 1.4G 77G 2% /

      En este caso, el espacio libre es 77G. Su espacio libre puede ser diferente.

      Utilice el comando fallocate, que le permite preasignar o desasignar el espacio a un archivo, para crear un archivo que ocupa más del 80 % del espacio disponible en el disco. Esto será suficiente para activar la alerta:

      • fallocate -l 70G /tmp/temp.img

      Tras aproximadamente una hora, Zabbix activará una alerta sobre la cantidad de espacio libre en el disco y ejecutará la acción que configuró, enviando el mensaje de notificación. Puede comprobar su buzón de entrada en busca del mensaje del servidor Zabbix. Verá un mensaje como este:

      Problem started at 09:49:08 on 2020.06.12
      Problem name: /: Disk space is low (used > 80%)
      Host: Second Ubuntu Server
      Severity: Warning
      Operational data: Space used: 71.34 GB of 77.36 GB (92.23 %)
      Original problem ID: 106
      

      También puede navegar a la pestaña Monitorización y luego a Panel de control para ver la notificación y sus detalles.

      Panel de control principal

      Ahora que sabe que las alertas están funcionando, elimine el archivo temporal que creó para que pueda reclamar su espacio en disco:

      Tras un minuto Zabbix enviará un mensaje de recuperación y la alerta desaparecerá del panel de control principal.

      Conclusión

      En este tutorial, ha aprendido a configurar una solución de monitorización sencilla y segura que le ayudará a monitorizar el estado de sus servidores. Ahora puede avisarle si existen problemas, y podrá analizar los procesos que se producen en su infraestructura de TI.

      Para obtener más información sobre cómo configurar una infraestructura de monitorización, consulte nuestra página sobre el tema Monitorización.



      Source link