One place for hosting & domains

      Sysadmin eBook: Cómo hacer funcionar los servidores


      Descargue todo el EBook

      Libro electrónico Cómo hacer funcionar los servidores: Guía práctica para la administración de sistemas en formato EPUB

      Libro electrónico Cómo hacer funcionar los servidores: Guía práctica para la administración de sistemas en formato PDF

      Introducción al libro electrónico

      En este libro, se destacan las habilidades prácticas de los administradores de sistemas, las arquitecturas comunes que encontrará y las mejores prácticas que se aplican a la automatización y la ejecución de sistemas a cualquier escala, desde una computadora portátil o un servidor hasta 1000 o más.  Está diseñado para ayudar a orientarlo dentro de la disciplina, y esperamos que lo anime a aprender más sobre la administración de sistemas.

      Este libro se basa en el plan de estudios Cómo hacer funcionar servidores: guía práctica para la administración de sistemas Linux, disponible en la comunidad de DigitalOcean. Su estructura se basa en algunos temas centrales:

      1. Temas introductorios

      2. Pilas de tecnología LAMP y LEMP

      3. Proteger sus servidores

      4. Automatización con Ansible

      5. Control de versiones e integración continua

      Puede elegir los temas de este libro que le interesen y explorarlos usando estos capítulos como guía. Trabajar con este libro lo expondrá a una amplia variedad de tecnologías, términos técnicos y enfoques conceptuales para administrar servidores de Linux. Puede trabajar con cada capítulo o sección a su propio ritmo y en cualquier orden que desee.

      Descargar el libro electrónico

      Puede descargar el libro electrónico en formato EPUB o PDF siguiendo los enlaces que se muestran a continuación.

      Descargue todo el EBook

      Libro electrónico Cómo hacer funcionar los servidores: Guía práctica para la administración de sistemas en formato EPUB

      Libro electrónico Cómo hacer funcionar servidores: guía práctica para la administración de sistemas en formato PDF

      Para obtener recursos adicionales de administración de sistemas que lo ayuden a comenzar, y para participar en la comunidad de DigitalOcean de otros desarrolladores y administradores, consulte nuestra creciente biblioteca de tutoriales, preguntas y proyectos con la etiqueta “Introducción”.



      Source link

      Cómo hacer cálculos matemáticos en Go con operadores


      Introducción

      En el ámbito de la programación, los números son comunes. Se utilizan para representar aspectos como dimensiones de tamaños de pantalla, ubicaciones geográficas, dinero y puntos, el tiempo transcurrido de un video, posiciones de avatares, colores mediante la asignación de códigos numéricos, entre otros.

      En el sector de la programación, desarrollar la capacidad de realizar operaciones matemáticas de forma eficaz es importante debido a la frecuencia con la que se trabaja con números. Si bien tener conocimientos matemáticos avanzados ciertamente puede servirle a programar mejor, no es un requisito previo. Si no tiene conocimientos matemáticos previos, trate concebir la matemática como una herramienta para lograr sus objetivos y como una forma de mejorar su pensamiento lógico.

      Trabajaremos con dos de los tipos de datos numéricos más utilizados en Go: enteros y flotantes:

      • Los enteros son números enteros que pueden ser positivos, negativos o 0 (…, -1, 0, 1,…).
      • Los flotantes son números reales que contienen un punto decimal, como 9.0 o -2.25.

      En este tutorial, analizaremos los operadores que podemos usar con tipos de datos numéricos en Go.

      Operadores

      Un operador es un símbolo o una función que indica una operación. Por ejemplo, en matemática, el signo más o + es el operador que indica suma.

      En Go, veremos algunos operadores conocidos que provienen de la matemática. Sin embargo, otros operadores que usaremos son específicos de la programación informática.

      A continuación, se muestra una tabla de referencia rápida de los operadores relacionados con la matemática que se usan en Go. En este tutorial se abarcan todas las funciones que se indican a continuación.

      Operación Lo que muestra
      x + y​​​ Suma de x e y
      x - y​​ Diferencia entre x e y
      -x Cambio de signo de x
      +x Identidad de x
      x * y​​ Producto de x e y
      x / y​ Cociente de x e y
      x % y​​ Resto de x e y

      También veremos los operadores de asignación compuestos, como += y *=, en los que se combinan un operador aritmético con el operador =.

      Suma y resta

      En Go, los operadores de resta funcionan con los mismos principios que la operación matemática. De hecho, puede usar el lenguaje de programación Go como una calculadora.

      Veamos algunos ejemplos, comenzando por los enteros:

      fmt.Println(1 + 5)
      

      Output

      6

      En lugar de pasar enteros directamente a la instrucción fmt.Println, podemos inicializar variables que representen valores enteros usando sintaxis como la siguiente:

      a := 88
      b := 103
      
      fmt.Println(a + b)
      

      Output

      191

      Debido a que los números enteros pueden ser tanto positivos como negativos (y también 0), podemos añadir un número negativo con uno positivo:

      c := -36
      d := 25
      
      fmt.Println(c + d)
      

      Output

      -11

      La adición se comportará de manera similar con los flotantes:

      e := 5.5
      f := 2.5
      
      fmt.Println(e + f)
      

      Output

      8

      Debido a que añadimos dos flotantes juntos, Go devolvió un valor flotante con un decimal. Sin embargo, como la posición decimal es cero en este caso, fmt.Println no utilizó el formato decimal. Para darle al resultado el formato adecuado, podemos utilizar fmt.Printf y el verbo %.2f, que dará el formato de dos posiciones decimales, como se indica en este ejemplo:

      fmt.Printf("%.2f", e + f)
      

      Output

      8.00

      La sintaxis para la resta es la misma que la de la suma, con la excepción de que cambiamos nuestro operador de signo más (+) por el de signo menos (-):

      g := 75.67
      h := 32.0
      
      fmt.Println(g - h)
      

      Output

      43.67

      En Go, solo podemos usar operadores en los mismos tipos de datos. No podemos añadir un int y un float64:

      i := 7
      j := 7.0
      fmt.Println(i + j)
      

      Output

      i + j (mismatched types int and float64)

      Si se intenta usar operadores en tipos de datos que no son los mismos se producirá en error de compilación.

      Operaciones aritméticas unarias

      Las expresiones matemáticas unarias constan de un solo componente o elemento. En Go, podemos usar los signos más y menos como elementos únicos en combinación con un valor para mostrar la identidad del valor (+) o cambiar el signo del valor (-).

      Aunque no se utiliza comúnmente, el signo más indica la identidad del valor. Podemos usar el signo más con valores positivos:

      i := 3.3
      fmt.Println(+i)
      

      Output

      3.3

      Cuando usamos el signo más con un valor negativo, también devuelve la identidad de ese valor, pero en este caso será negativo:

      j := -19
      fmt.Println(+j)
      

      Output

      -19

      Con un valor negativo, el signo más devuelve el mismo valor negativo.

      Sin embargo, el signo menos cambia el signo de un valor. Por lo tanto, al pasar un valor positivo, notaremos que el signo menos antes del valor mostrará un valor negativo:

      k := 3.3
      fmt.Println(-k)
      

      Output

      -3.3

      De forma alternativa, al usar el operador unario de signo menos con un valor negativo, se muestra un valor positivo:

      j := -19
      fmt.Println(-j)
      

      Output

      19

      Las operaciones aritméticas unarias indicadas por el signo más y el signo menos devolverán la identidad del valor, como en el caso de +i, o el signo opuesto del valor, como sucede con -i.

      Multiplicación y división

      Al igual que la suma y la resta, la multiplicación y la división tienen un funcionamiento muy similar al de las operaciones matemáticas. El signo que usaremos en Go para multiplicar es * y el signo para dividir es /.

      Aquí tenemos un ejemplo de cómo hacer una multiplicación en Go con dos valores flotantes:

      k := 100.2
      l := 10.2
      
      fmt.Println(k * l)
      

      Output

      1022.04

      En Go, la división tiene características diferentes según el tipo numérico que dividamos.

      Si dividimos enteros, el operador / de Go realiza una división de piso, en la que, para el cociente x, se muestra el número entero más grande menor o igual que x.

      Si ejecuta el siguiente ejemplo de división 80 / 6, obtendrá 13 como resultado y el tipo de datos será int:

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          m := 80
          n := 6
      
          fmt.Println(m / n)
      }
      

      Output

      13

      Para obtener un flotante como resultado, debe convertir los valores de forma explícita antes de la división.

      Puede hacerlo envolviendo sus valores con el tipo de flotante que desee, float32() o float64():

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          s := 80
          t := 6
          r := float64(s) / float64(t)
          fmt.Println(r)
      }
      

      Output

      13.333333333333334

      Módulo

      El operador % es el módulo, que muestra el resto en lugar del cociente después de la división. Esto es útil para encontrar números que son múltiplos de un mismo número.

      Veamos un ejemplo del módulo:

      o := 85
      p := 15
      
      fmt.Println(o % p)
      

      Output

      10

      Para desglosarlo, de la división de 85 por 15 se obtiene el cociente 5 con un resto de 10. Aquí, nuestro programa muestra el valor 10 porque el operador de módulo muestra el resto de una expresión de división.

      Para hacer cálculos con módulos con tipos de datos float64, usará la función Mod del paquete math:

      package main
      
      import (
          "fmt"
          "math"
      )
      
      func main() {
          q := 36.0
          r := 8.0
      
          s := math.Mod(q, r)
      
          fmt.Println(s)
      }
      

      Output

      4

      Prioridad de los operadores

      En Go, al igual que en la matemática, debemos tener en cuenta que los operadores se evaluarán en orden de prioridad, no de izquierda a derecha o de derecha a izquierda.

      Si observamos la siguiente expresión matemática:

      u = 10 + 10 * 5
      

      Podemos leerla de izquierda a derecha, pero la multiplicación se realizará primero. Por lo tanto, si imprimiéramos u obtendríamos el siguiente valor:

      Output

      60

      Esto se debe a que 10 * 5 da como resultado 50, y luego sumamos 10 para obtener 60 como resultado final.

      Si, como alternativa, queremos sumar el valor 10 a 10 y luego multiplicar esa suma por 5, en Go debemos usar paréntesis tal como lo haríamos en el campo de la matemática:

      u := (10 + 10) * 5
      fmt.Println(u)
      

      Output

      100

      Una opción para recordar el orden de las operaciones es el acrónimo PEMDAS:

      Orden Letra Representa
      1 P Paréntesis
      2 E Exponente
      3 M Multiplicación
      4 D División
      5 A Suma
      6 S Resta

      Es posible que esté familiarizado con otros acrónimos, como BEDMAS o BODMAS, para recordar el orden de las operaciones. Sea cual sea el acrónimo que le resulte más útil, intente tenerlo en cuenta al realizar operaciones matemáticas en Go para obtener los resultados esperados.

      Operadores de asignación

      El operador de asignación más frecuente es uno que ya utilizó: el signo igual =. El operador = le asigna el valor de la derecha a una variable a la izquierda. Por ejemplo, v = 23 asigna el valor del número entero 23 a la variable v.

      Durante la programación, es común usar operadores de asignación compuestos que realizan una operación en el valor de una variable y luego asignan el valor nuevo resultante a esa variable. Estos operadores compuestos combinan un operador aritmético con el operador = Por lo tanto, para la adición, combinaremos + con = para obtener el operador compuesto +=. Observemos cómo se ve:

      w := 5
      w += 1
      fmt.Println(w)
      

      Output

      6

      Primero, configuramos la variable w equivalente al valor de 5, luego usamos el operador de asignación += para sumar el número de la derecha al valor de la variable izquierda y, a continuación, asignamos el resultado a w.

      Los operadores de asignación compuestos se utilizan frecuentemente en los bucles for, que emplearemos cuando queramos repetir un proceso varias veces:

      package main
      
      import "fmt"
      
      func main() {
      
          values := []int{0, 1, 2, 3, 4, 5, 6}
      
          for _, x := range values {
      
              w := x
      
              w *= 2
      
              fmt.Println(w)
          }
      
      }
      

      Output

      0 2 4 6 8 10 12

      Usando un bucle for para iterar el elemento llamado values, pudo automatizar el proceso del operador *=, que multiplicó la variable w por el número 2, y luego volvió a asignar el resultado a la variable w.

      Go cuenta con un operador de asignación compuesto para cada uno de los operadores aritméticos que se analizan en este tutorial.

      Para sumar y luego asignar el valor:

      y += 1
      

      Para restar y luego asignar el valor:

      y -= 1
      

      Para multiplicar y luego asignar el valor:

      y *= 2
      

      Para dividir y luego asignar el valor:

      y /= 3
      

      Para mostrar el resto y luego asignar el valor:

      y %= 3
      

      Los operadores de asignación compuestos pueden ser útiles cuando se debe realizar un aumento o una reducción incremental o cuando se deben automatizar determinados procesos de un programa.

      Conclusión

      En este tutorial, se analizaron muchos de los operadores que usará con los tipos de datos numéricos enteros y flotantes. Puede aprender más sobre los diferentes tipos de datos en Información sobre tipos de datos en Go y Cómo convertir tipos de datos.



      Source link

      Cómo hacer funcionar aplicaciones de Flask con uWSGI y Nginx en Ubuntu 18.04


      Introducción

      A través de esta guía, creará una aplicación de Python utilizando el microframework de Flask en Ubuntu 18.04. En la mayor parte de este artículo se abordarán la configuración del servidor de la aplicación uWSGI y la forma de iniciar la aplicación y configurar Nginx para que funcione como un proxy inverso de cliente.

      Requisitos previos

      Antes de comenzar con esta guía, deberá contar con lo siguiente:

      • Un servidor con Ubuntu 18.04 instalado y un usuario no root con privilegios sudo. Siga nuestra guía de configuración inicial para servidores a modo de orientación.
      • Nginx instalado conforme a los pasos 1 y 2 de Cómo instalar Nginx en Ubuntu 18.04.
      • Un nombre de dominio configurado para que apunte a su servidor. Puede adquirir uno en Namecheap obtener uno de forma gratuita en Freenom. Puede aprender a apuntar dominios a DigitalOcean siguiendo la documentación sobre dominios y DNS pertinente. Asegúrese de crear los siguientes registros DNS:

        • Un registro A con your_domain orientado a la dirección IP pública de su servidor.
        • Un registro A con www.your_domain orientado a la dirección IP pública de su servidor.
      • Conocimientos sobre uWSGI, nuestro servidor de aplicaciones y la especificación WSGI. En esta discusión de definiciones y conceptos se abordan ambos en profundidad.

      Paso 1: Instalar los componentes desde los repositorios de Ubuntu

      Nuestro primer paso será instalar todo lo que necesitamos desde los repositorios de Ubuntu. Instalaremos pip, el administrador de paquetes de Python, para administrar nuestros componentes de Python. También obtendremos los archivos de desarrollo de Python necesarios para crear uWSGI.

      Primero, actualizaremos el índice de paquetes locales e instalaremos los paquetes que nos permitirán crear nuestro entorno de Python. Entre ellos está phyton3-pip, junto con paquetes y herramientas de desarrollo adicionales que se necesitan para un entorno de programación sólido:

      • sudo apt update
      • sudo apt install python3-pip python3-dev build-essential libssl-dev libffi-dev python3-setuptools

      Una vez implementados estos paquetes, crearemos un entorno virtual para nuestro proyecto.

      Paso 2: Crear un entorno virtual de Python

      A continuación, configuraremos un entorno virtual para aislar nuestra aplicación de Flask de los otros archivos de Python del sistema.

      Comience instalando el paquete phyton3-venv, que instalará el módulo venv:

      • sudo apt install python3-venv

      Luego, crearemos un directorio principal para nuestro proyecto de Flask. Después de crearlo, posiciónese en él:

      • mkdir ~/myproject
      • cd ~/myproject

      Cree un entorno virtual para almacenar los requisitos de Python de su proyecto de Flask escribiendo lo siguiente:

      • python3.6 -m venv myprojectenv

      Con esto se instalará una copia local de Python y pip en un directorio llamado myprojectenv dentro del directorio de su proyecto.

      Antes de instalar aplicaciones dentro del entorno virtual, deberá activarlo. Hágalo escribiendo lo siguiente:

      • source myprojectenv/bin/activate

      Su mensaje cambiará para indicar que ahora realiza operaciones dentro del entorno virtual. Se parecerá a esto: (myprojectenv)user@host:~/myproject$.

      Paso 3: Configurar una aplicación de Flask

      Ahora que se encuentra en su entorno virtual, podrá instalar Flask y uWSGI y comenzar a diseñar su aplicación.

      Primero, instalaremos wheel con la instancia local de pip para asegurarnos de que nuestros paquetes se instalen aunque falten archivos de wheel:

      Nota: Independientemente de la versión de Phyton que use, cuando se active el entorno virtual deberá utilizar el comando pip (no pip3).

      A continuación, instalaremos Flask y uWSGI:

      Creación de una aplicación de ejemplo

      Ahora que dispone de Flask, puede crear una aplicación sencilla. Flask es un microframework. No cuenta con muchas de las herramientas que podrían incluirse en frameworks con más características y existe sobre todo como un módulo que puede importar a sus proyectos para que pueda inicializar una aplicación web.

      Aunque la complejidad podría ser mayor, crearemos nuestra aplicación de Flask en un único archivo, llamado “myproject.py:

      • nano ~/myproject/myproject.py

      El código de aplicación residirá en este archivo. Importará Flask y creará una instancia de un objeto de Flask. Puede utilizarlo para definir las funciones que deberían ejecutarse cuando se solicita una ruta específica:

      ~/myproject/myproject.py

      from flask import Flask
      app = Flask(__name__)
      
      @app.route("/")
      def hello():
          return "<h1 style='color:blue'>Hello There!</h1>"
      
      if __name__ == "__main__":
          app.run(host='0.0.0.0')
      

      Esto define básicamente el contenido que se presentará al acceder al dominio root. Guarde y cierre el archivo cuando termine.

      Si siguió la guía de configuración inicial para servidores, debería tener activado un firewall UFW. Para probar la aplicación, debe permitir el acceso al puerto 5000:

      Ahora podrá probar su aplicación de Flask escribiendo lo siguiente:

      Verá un resultado como el siguiente, en el cual se incluirá una advertencia útil que le recordará no utilizar esta configuración de servidor en la producción:

      Output

      * Serving Flask app "myproject" (lazy loading) * Environment: production WARNING: Do not use the development server in a production environment. Use a production WSGI server instead. * Debug mode: off * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

      Agregue :5000 al final de la dirección IP de su servidor en su navegador web y visítela:

      http://your_server_ip:5000
      

      Debería ver algo como esto:

      Aplicación de ejemplo de Flask

      Cuanto termine, pulse CTRL-C en la ventana de su terminal para detener el servidor de desarrollo Flask.

      Creación de un punto de entrada de WSGI

      A continuación, crearemos un archivo que servirá como punto de entrada para nuestra aplicación. Esto le indicará a nuestro servidor de uWSGI cómo interactuar con él.

      Llamaremos al archivo wsgi.py:

      En él, importaremos la instancia de Flask desde nuestra aplicación y luego la ejecutaremos:

      ~/myproject/wsgi.py

      from myproject import app
      
      if __name__ == "__main__":
          app.run()
      

      Guarde y cierre el archivo cuando termine.

      Paso 4: Configurar uWSGI

      Su aplicación quedará, así, escrita con un punto de entrada establecido. Ahora, podemos continuar con la configuración de uWSGI.

      Prueba del servicio de uWSGI

      Haremos una prueba para comprobar que uWSGI pueda hacer funcionar nuestra aplicación.

      Lo haremos con solo pasarle el nombre de nuestro punto de entrada. Se construye como el nombre del módulo (menos la extensión .py) más el nombre del elemento invocable dentro de la aplicación. En nuestro caso, es wsgi:app.

      También especificaremos el socket, de modo que se inicie en una interfaz disponible de forma pública, además del protocolo, para que utilice HTTP en lugar del protocolo binario uwsgi. Utilizaremos el mismo número de puerto, 5000, que abrimos antes:

      • uwsgi --socket 0.0.0.0:5000 --protocol=http -w wsgi:app

      Visite de nuevo la dirección IP de su servidor con :5000 agregado al final en su navegador web:

      http://your_server_ip:5000
      

      Debería volver a ver el resultado de su aplicación:

      Aplicación de ejemplo de Flask

      Cuando confirme que funciona correctamente, pulse CTRL-C en la ventana de su terminal.

      Ya completamos las tareas de nuestro entorno virtual, por lo que podemos desactivarlo:

      Ahora todos los comandos de Python usarán de nuevo el entorno de Phyton del sistema.

      Creación de un archivo de configuración de uWSGI

      Ya comprobó que uWSGI puede hacer funcionar su aplicación. Sin embargo, en última instancia le convendrá algo más sólido para el uso a largo plazo. Puede crear un archivo de configuración de uWSGI con las opciones pertinentes para esto.

      Dispondremos ese archivo en nuestro directorio de proyectos y lo llamaremos myproject.ini:

      • nano ~/myproject/myproject.ini

      En su interior, empezaremos con el encabezado de [uwsgi] a fin de que uWSGI esté al tanto para aplicar la configuración. Especificaremos dos cosas: el propio módulo, haciendo referencia al archivo wsgi.py menos la extensión, y el elemento invocable dentro del archivo, app:

      ~/myproject/myproject.ini

      [uwsgi]
      module = wsgi:app
      

      A continuación, le diremos a uWSGI que se inicie en el modo maestro y cree cinco procesos de trabajador para proporcionar solicitudes reales:

      ~/myproject/myproject.ini

      [uwsgi]
      module = wsgi:app
      
      master = true
      processes = 5
      

      Cuando hizo pruebas, expuso uWSGI en un puerto de red. Sin embargo, utilizará Nginx para gestionar las conexiones de clientes reales, que luego transmitirán solicitudes a uWSGI. Debido a que estos componentes funcionan en la misma computadora, es preferible un socket de Unix porque es más rápido y seguro. Llamaremos al socket myproject.sock y lo dispondremos en este directorio.

      También cambiaremos los permisos del socket. Más adelante, daremos al grupo de Nginx la propiedad del proceso de uWSGI, por lo que debemos verificar que el propietario de grupo del socket pueda leer información de él y enviarle texto. También eliminaremos el socket cuando se detenga el proceso agregando la opción vacuum:

      ~/myproject/myproject.ini

      [uwsgi]
      module = wsgi:app
      
      master = true
      processes = 5
      
      socket = myproject.sock
      chmod-socket = 660
      vacuum = true
      

      Lo último que haremos será establecer la opción die-on-term. Esto puede ayudar a garantizar que el sistema init y uWSGI tengan los mismos supuestos sobre lo que significa cada señal de proceso. Al configurar esto se alinean los dos componentes del sistema y se implementa el comportamiento esperado:

      ~/myproject/myproject.ini

      [uwsgi]
      module = wsgi:app
      
      master = true
      processes = 5
      
      socket = myproject.sock
      chmod-socket = 660
      vacuum = true
      
      die-on-term = true
      

      Posibleemente haya observado que no especificamos un protocolo como hicimos desde la línea de comandos. Esto se debe a que, de forma predeterminada, uWSGI se comunica usando el protocolo de uwsgi, un protocolo binario rápido diseñado para la comunicación con otros servidores. Nginx puede comunicarse a través de este protocolo de forma nativa, por lo que es mejor usarlo que forzar la comunicación por HTTP.

      Cuando termine, guarde y cierre el archivo.

      Paso 5: Crear un archivo de unidad systemd

      A continuación, crearemos el archivo de unidad de servicio systemd. Crear un archivo de unidad systemd permitirá que el sistema init de Ubuntu inicie automáticamente uWSGI y haga funcionar la aplicación de Flask cuando el servidor se cargue.

      Cree un archivo de unidad terminado en .service dentro del directorio /etc/systemd/system para empezar:

      • sudo nano /etc/systemd/system/myproject.service

      En su interior, empezaremos con la sección [Unit] que se usa para especificar metadatos y dependencias. Aquí agregaremos una descripción de nuestro servicio e indicaremos al sistema init que lo inicie solo tras haber alcanzado el objetivo de red:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=uWSGI instance to serve myproject
      After=network.target
      

      A continuación, abriremos la sección [Service]. Esto especificará el usuario y el grupo con los cuales deseamos que se ejecute el proceso. Otorgaremos la propiedad del proceso a nuestra cuenta de usuario normal, ya que tiene la propiedad de todos los archivos pertinentes. También otorgaremos la propiedad del grupo al grupo www-data para que Nginx pueda comunicarse fácilmente con los procesos de Gunicorn. No se olvide de sustituir el nombre de usuario por el suyo:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=uWSGI instance to serve myproject
      After=network.target
      
      [Service]
      User=sammy
      Group=www-data
      

      A continuación, planearemos los detalles del directorio de trabajo y estableceremos el entorno variable PATH para que el sistema init sepa que los ejecutables para el proceso están ubicados dentro de nuestro entorno virtual. También especificaremos el comando para iniciar el servicio. Systemd necesita que le proporcionemos la ruta completa al ejecutable de uWSGI, que se instala dentro de nuestro entorno virtual. Pasaremos el nombre del archivo de configuración .ini que creamos en el directorio de nuestro proyecto.

      No se olvide de sustituir el nombre del usuario y las rutas del proyecto por su propia información:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=uWSGI instance to serve myproject
      After=network.target
      
      [Service]
      User=sammy
      Group=www-data
      WorkingDirectory=/home/sammy/myproject
      Environment="PATH=/home/sammy/myproject/myprojectenv/bin"
      ExecStart=/home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini
      

      Por último, vamos a añadiremos una sección [Install]. Esto indicará a systemd a qué deberá vincular este servicio si lo habilitamos para que se cargue en el inicio. Queremos que este servicio se inicie cuando el sistema multiusuario normal esté en funcionamiento:

      /etc/systemd/system/myproject.service

      [Unit]
      Description=uWSGI instance to serve myproject
      After=network.target
      
      [Service]
      User=sammy
      Group=www-data
      WorkingDirectory=/home/sammy/myproject
      Environment="PATH=/home/sammy/myproject/myprojectenv/bin"
      ExecStart=/home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini
      
      [Install]
      WantedBy=multi-user.target
      

      Con eso, nuestro archivo de servicio de systemd quedará completo. Guárdelo y ciérrelo ahora.

      Ya podemos iniciar el servicio uWSGI que creamos y activarlo para que se cargue en el inicio:

      • sudo systemctl start myproject
      • sudo systemctl enable myproject

      Comprobaremos el estado:

      • sudo systemctl status myproject

      Debería ver el siguiente resultado:

      Output

      ● myproject.service - uWSGI instance to serve myproject Loaded: loaded (/etc/systemd/system/myproject.service; enabled; vendor preset: enabled) Active: active (running) since Fri 2018-07-13 14:28:39 UTC; 46s ago Main PID: 30360 (uwsgi) Tasks: 6 (limit: 1153) CGroup: /system.slice/myproject.service ├─30360 /home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini ├─30378 /home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini ├─30379 /home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini ├─30380 /home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini ├─30381 /home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini └─30382 /home/sammy/myproject/myprojectenv/bin/uwsgi --ini myproject.ini

      Si detecta errores, asegúrese de resolverlos antes de continuar con el tutorial.

      Paso 6: Configurar Nginx para solicitudes de proxy

      Ahora, nuestro servidor de aplicación uWSGI debería estar funcionando, esperando solicitudes en el archivo de socket del directorio del proyecto. Configuraremos Nginx para que transmita las solicitudes web a ese socket usando el protocolo uwsgi.

      Comencemos creando un nuevo archivo de configuración de bloque de servidor en el directorio sites-available de Nginx. Lo llamaremos myproject para que se adecue al resto de esta guía:

      • sudo nano /etc/nginx/sites-available/myproject

      Abra un bloque de servidor e indique a Nginx que escuche en el puerto predeterminado 80. También le indicaremos que utilice este bloque para solicitudes para el nombre de dominio de nuestro servidor:

      /etc/nginx/sites-available/myproject

      server {
          listen 80;
          server_name your_domain www.your_domain;
      }
      

      A continuación, agregaremos un bloque de ubicación que coincida con cada solicitud. Dentro de este bloque, incluiremos el archivo proxy_params que especifica algunos parámetros de proxy generales de uWSGI que deben configurarse. Luego, pasaremos las solicitudes al socket que definimos usando la directiva proxy_pass:

      /etc/nginx/sites-available/myproject

      server {
          listen 80;
          server_name your_domain www.your_domain;
      
          location / {
              include uwsgi_params;
              uwsgi_pass unix:/home/sammy/myproject/myproject.sock;
          }
      }
      

      Guarde y cierre el archivo cuando termine.

      Para habilitar la configuración del bloque de servidor de Nginx que acaba de crear, vincule el archivo al directorio sites-enabled​​​:

      • sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

      Con el archivo en ese directorio, podemos probar si hay errores de sintaxis escribiendo lo siguiente:

      Si no se indican problemas, reinicie el proceso de Nginx para que lea la nueva configuración:

      • sudo systemctl restart nginx

      Por último, ajustaremos el firewall de nuevo. Ya no necesitamos acceso a través del puerto 5000, por lo que podemos eliminar esta regla. Luego podemos permitir el acceso al servidor de Nginx:

      • sudo ufw delete allow 5000
      • sudo ufw allow 'Nginx Full'

      Ahora debería poder visitar el nombre de dominio de su servidor en su navegador web:

      http://your_domain
      

      Debería ver el resultado de su aplicación:

      Aplicación de ejemplo de Flask

      Si encuentra algún error, intente verificar lo siguiente:

      • sudo less /var/log/nginx/error.log: verifica los registros de error de Nginx.
      • sudo less /var/log/nginx/access.log: verifica los registros de acceso de Nginx.
      • sudo journalctl -u nginx: verifica los registros de proceso de Nginx.
      • sudo journalctl -u myproject: verifica los registros de uWSGI de su aplicación de Flask.

      Paso 7: Proteger la aplicación

      Para asegurarse de que el tráfico hacia su servidor siga siendo seguro, obtendremos un certificado SSL para su dominio. Existen varias formas de hacerlo. Entre otras, obtener un certificado gratuito de Let’s Encrypt, generar un certificado autofirmado o adquirir uno de otro proveedor y configurar Nginx para que lo utilice siguiendo los pasos 2 a 6 de Cómo crear un certificado SSL autofirmado para Nginx en Ubuntu 18.04. Por motivos de conveniencia, elegiremos la primera opción.

      Primero, agregue el repositorio de Certbot de Ubuntu:

      • sudo add-apt-repository ppa:certbot/certbot

      Deberá seleccionar ENTER para aceptar.

      Instale el paquete de Nginx de Certbot con apt:

      • sudo apt install python-certbot-nginx

      Certbot ofrece varias alternativas para obtener certificados SSL a través de complementos. El complemento de Nginx se encargará de reconfigurar Nginx y volver a cargar la configuración cuando sea necesario. Para utilizar este complemento, escriba lo siguiente:

      • sudo certbot --nginx -d your_domain -d www.your_domain

      Con esto, se ejecuta certbot con el complemento --nginx usando -d para especificar los nombres para los cuales deseamos que el certificado tenga validez.

      Si es la primera vez que ejecuta certbot, se le solicitará introducir una dirección de correo electrónico y aceptar las condiciones de servicio. Después de esto, certbot se comunicará con el servidor de Let’s Encrypt y realizará una comprobación a fin de verificar que usted controle el dominio para el cual solicite un certificado.

      Si la comprobación se realiza correctamente, certbot le preguntará cómo desea configurar sus ajustes de HTTPS:

      Output

      Please choose whether or not to redirect HTTP traffic to HTTPS, removing HTTP access. ------------------------------------------------------------------------------- 1: No redirect - Make no further changes to the webserver configuration. 2: Redirect - Make all requests redirect to secure HTTPS access. Choose this for new sites, or if you're confident your site works on HTTPS. You can undo this change by editing your web server's configuration. ------------------------------------------------------------------------------- Select the appropriate number [1-2] then [enter] (press 'c' to cancel):

      Seleccione su elección y luego ENTER. La configuración se actualizará y Nginx se volverá a cargar para aplicar los ajustes nuevos. certbot concluirá con un mensaje que le indicará que el proceso tuvo éxito e indicará la ubicación de almacenamiento de sus certificados:

      Output

      IMPORTANT NOTES: - Congratulations! Your certificate and chain have been saved at: /etc/letsencrypt/live/your_domain/fullchain.pem Your key file has been saved at: /etc/letsencrypt/live/your_domain/privkey.pem Your cert will expire on 2018-07-23. To obtain a new or tweaked version of this certificate in the future, simply run certbot again with the "certonly" option. To non-interactively renew *all* of your certificates, run "certbot renew" - Your account credentials have been saved in your Certbot configuration directory at /etc/letsencrypt. You should make a secure backup of this folder now. This configuration directory will also contain certificates and private keys obtained by Certbot so making regular backups of this folder is ideal. - If you like Certbot, please consider supporting our work by: Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate Donating to EFF: https://eff.org/donate-le

      Si siguió las instrucciones de instalación de Nginx en los requisitos previos, ya no necesitará la asignación de perfil HTTP redundante:

      • sudo ufw delete allow 'Nginx HTTP'

      Para verificar la configuración, acceda una vez más a su dominio utilizando https://:

      https://your_domain
      

      Una vez más, debería ver el resultado de su aplicación junto con el indicador de seguridad de su navegador, que debería indicar que el sitio está protegido.

      Conclusión

      A través de esta guía, creó y aseguró una aplicación de Flask simple dentro de un entorno virtual de Python. Creó un punto de entrada de WSGI para que cualquier servidor de aplicación con capacidad para WSGI pueda interactuar con él y configuró el servidor de aplicación de uWSGI para proporcionar esta función. Luego, creó un archivo de servicio systemd para iniciar automáticamente el servidor de aplicación en el inicio. También creó un bloque de servidor de Nginx que transmite el tráfico de clientes web al servidor de la aplicación, y reenvía solicitudes externas, y protegió el tráfico hacia su servidor con Let’s Encrypt.

      Flask es un framework muy sencillo, pero extremadamente flexible, diseñado para proporcionar funcionalidad a sus aplicaciones sin ser demasiado restrictivo respecto de la estructura y del diseño. Puede utilizar la pila general descrita en esta guía para hacer funcionar las aplicaciones de Flask que diseñe.



      Source link