Site is under maintenance mode. Please wait few min!
Saltar al contenido

Cómo adquirir un certificado Let’s Encrypt usando Ansible en Ubuntu 18.04

marzo 4, 2020

 

Introducción

Copia de seguridad de los datos importantes es una parte esencial de la gestión de cualquier infraestructura informática. Aunque las necesidades de cada persona son diferentes cuando se trata de realizar copias de seguridad, el mantenimiento de los datos de copia de seguridad en una ubicación externa es una práctica buena.

El proceso de envío de copias de datos a una ubicación fuera del sitio que solía ser un gran reto logístico. Pero con la llegada de los servicios de almacenamiento en la nube como CrashPlan y Dropbox, así como el desarrollo de soluciones de almacenamiento de objetos como espacios digitalocean, ahora se ha convertido en una tarea mucho más sencilla. A pesar de esto, sin olvidarse de copia de seguridad de archivos y tomarse el tiempo para subirlos todavía puede ser un obstáculo para algunos.

Esta es la razón por la gente elige utilizar diversas herramientas para realizar copias de seguridad rutinarias y automáticas de sus datos importantes. En este tutorial, vamos a construir un guión alrededor de la herramienta de línea de comandos s3cmd que se puede utilizar para cargar rápidamente los datos a los espacios digitalocean. a continuación, vamos a utilizar crontab para regular invocar el script copias de seguridad y subir archivos a nuestro espacio.

Requisitos previos

Para este tutorial, necesitará:

  • Una Ubuntu 16.04 x64 de gotas con un usuario que no sea root sudo. Esto se puede configurar siguiendo nuestra guía inicial de configuración del servidor para Ubuntu 16.04.
  • Un espacio digitalocean y la clave de acceso a la API.
  • El s3cmd herramienta de línea de comando instalado en el droplet.

Tener cierta familiaridad con secuencias de comandos shell y el planificador de tareas cron también podría ser útil. Por alguna orientación y contexto adicional, considere la lectura de “Introducción a la Shell Scripting” y “cómo las tareas de rutina para programar mediante Cron y Anacron en un VPS.”

Con nuestros requisitos en su lugar, estamos listos para iniciar nuestro proceso de copia de seguridad automática.

Edificio nuestras copias de seguridad de secuencias de comandos

Hay una serie de herramientas que se pueden utilizar para cargar los archivos de copia de seguridad a un servicio de almacenamiento de objetos de forma automática y en intervalos regulares. Sin embargo, estos pueden ser difíciles de configurar y no pueden ofrecer mucho en el camino de la flexibilidad. El uso de un simple script de shell puede ser un enfoque mucho más elegante y fácil de automatizar las copias de seguridad de almacenamiento de objetos.

Para este tutorial, vamos a escribir una escritura del golpe básico que creará una copia de seguridad de un archivo o directorio en el alquitrán. La secuencia de comandos a continuación, cargar la copia de seguridad de los espacios mediante la utilidad de línea de comandos s3cmd.

Para empezar, acceda a su gotitas y navegar a la carpeta de inicio:

cd ~

  • cd ~

Una vez en la carpeta de inicio, usaremos nano para crear un archivo vacío en el que podemos escribir en nuestro script:

nano bkupscript.sh

  • nano bkupscript.sh

ahora estamos listos para comenzar a escribir nuestro guión copias de seguridad en el editor de texto. A medida que construimos el guión, vamos a explicar cada parte de ella con el fin, sección por sección.

Iniciación nuestro script

En este punto, bkupscript.sh sólo es un archivo de texto vacío. Para que nuestro ordenador para invocar nuestro archivo ejecutable como comandos, necesitamos comenzar nuestro script con un Hashbang . Un Hashbang es una directiva intérprete que permite a los scripts o archivos de datos que se ejecutan como comandos.

En nuestro caso, el Hashbang se verá así:

#!/bin/bash

Al incluir esto en la parte superior de la secuencia de comandos, se indica a la shell para ejecutar los comandos del archivo en bash.

Declaración de variables

A continuación, vamos a decirle a nuestro script de las variables que se necesita saber para funcionar correctamente. Podemos agregar éstos directamente debajo de la Hashbang en la parte superior del archivo de texto: Ir de

...
DATETIME=`date +%y%m%d-%H_%M_%S`
SRC=$1
DST=$2
GIVENNAME=$3

Let través de lo que estamos asignando cada una de estas variables a:

  • DATETIME: Esta variable contiene una marca de tiempo para fijar al nombre del archivo resultante para cada archivo de copia de seguridad en nuestro espacio tiene un nombre único. Esta marca de tiempo se crea mediante la invocación de la orden de fecha y el formato de la salida para mostrar los dos últimos dígitos del año (% a), los dos dígitos del mes (% m), los dos dígitos del día (% d), la hora (% H), los minutos (% M) y la segundo (% s).
  • SRC: Esta es la ruta de origen para el archivo o carpeta que queremos hacer copias de seguridad. El $ 1 indica que estamos tomando este valor desde el primer parámetro pasado al script.
  • el horario de verano: Esta variable representa el destino del archivo. En nuestro caso este es el nombre del espacio a la que nos estamos introduciendo la copia de seguridad. Este nombre proviene de la segunda parámetro pasado a la secuencia de comandos como se indica por los $ 2.
  • givenname: Esta anfitriones variables el nombre elegido por el usuario para el archivo de destino. El nombre del archivo resultante se iniciará con givenname y tendrá la DATETIME concatena en la misma. Este nombre proviene del tercer parámetro pasado al script (3 $).

Proporcionar Ayuda

Al escribir un guión, es útil añadir algunos consejos o consejos generales que pueden ayudar a los usuarios la solución de problemas si sus intentos de utilizar fracasar.

Para nuestro script de copias de seguridad, vamos a añadir una función llamada showHelp () por debajo de nuestras variables. Esto imprimirá una serie de mensajes a los usuarios ayudar a solucionar por si falla el guión. Al agregar una función en bash, nuestra sintaxis será la siguiente:

...
showhelp(){

}

Esta función proporcionará mensajes de ayuda haciendo eco de una serie de instrucciones de uso de la pantalla. Cada instrucción debe ser presentada como una cadena encerrada entre comillas dobles. Se dará cuenta de que en nuestro ejemplo a continuación que algunas de las cadenas tienen to n escritos en su principio o al final. Estos son caracteres de escape que proporcionan instrucciones específicas de cómo la cadena debe aparecer en la salida del script:

  • t indica un espacio pestaña
  • n indica un salto de línea

dude en para añadir cualquier detalles de uso que se ser útil para usted en entre las llaves (sólo recuerda a preceder a cualquier cadena con eco). Para fines de demostración, vamos a añadir lo siguiente:

echo "nn############################################"
echo "# bkupscript.sh #"
echo "############################################"
echo "nThis script will backup files/folders into a single compressed file and will store it in the current folder."
echo "In order to work, this script needs the following three parameters in the listed order: "
echo "t- The full path for the folder or file you want to backup."
echo "t- The name of the Space where you want to store the backup at."
echo "t- The name for the backup file (timestamp will be added to the beginning of the filename)n"
echo "Example: sh bckupscript.sh .estdir testSpace backupdatan"<^>

La función showHelp final debe ser algo como esto:

...
showhelp(
echo "nn############################################"
echo "# bkupscript.sh #"
echo "############################################"
echo "nThis script will backup files/folders into a single compressed file and will store it in the current folder."
echo "In order to work, this script needs the following three parameters in the listed order: "
echo "t- The full path for the folder or file you want to backup."
echo "t- The name of the Space where you want to store the backup at."
echo "t- The name for the backup file (timestamp will be added to the beginning of the filename)n"
echo "Example: sh bckupscript.sh .estdir testSpace backupdatan"
}

Con nuestro texto de ayuda en su lugar, podemos pasar a recoger los archivos que nos gustaría hacer copias de seguridad en nuestro espacio. Archivos

Encuentro

Antes de nuestro script puede transferir nada a nuestro espacio, primero se necesita reunir los archivos correctos y consolidarlos en un solo paquete para que nos pongamos. Podemos lograr esto mediante la utilidad de alquitrán y una sentencia condicional. Debido a que estamos usando tar para crear un archivo de almacenamiento (a veces conocido como un archivo “zip”), vamos a llamar a esta función tarandzip (). inicio de

Let declarando la función y la adición de otro comando echo para que los usuarios sepan que el guión ha comenzado archivos de recopilación:

...
tarandzip(){
echo "n##### Gathering files #####n"
}

A continuación el comando echo, podemos añadir un comando tar, que va a hacer el trabajo de recolección y compresión de los archivos en un único archivo de salida.

tarandzip(){
echo "n##### Gathering files #####n"
tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC
}

Se dará cuenta de que este comando tar se invoca con varias opciones y variables:

  • c: Esta bandera le dice a tar para comprimir el archivo de salida.
  • z: Esto indica a tar para comprimir el archivo usando gzip.
  • v: Esto significa la opción de detalle, que indica a tar para mostrar más información en la salida.
  • f: Esta bandera instruye alquitrán para guardar el archivo con el nombre de archivo indica a continuación.
  • $ GIVENNAME- $ DATETIME.tar.gz: La secuencia de comandos llama a estas variables que que declaramos al principio con el fin de crear el nuevo nombre de archivo. Esto se logra mediante la combinación de la givenname $ y $ variables de fecha y hora y añadiendo la extensión .tar.gz hasta el final para formar el nuevo nombre de archivo.
  • $ SRC: Esta variable representa los archivos de origen o carpetas que están instruyendo tar para realizar copias de seguridad.

Esta función ahora debería ser capaz de hacer lo que queremos, pero podemos añadir unas cuantas llamadas más eco para dar al usuario cierta información adicional acerca de cómo está trabajando el guión. Esto puede hacerse mediante la adición de un par de sentencias condicionales, así:

if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
echo "n##### Done gathering files #####n"
return 0
else
echo "n##### Failed to gather files #####n"
return 1
fi

Cuando se invoca la cláusula if, se ejecutará el comando tar y esperar el resultado. Si el resultado del comando es positivo (es decir, que se ejecutó correctamente), se ejecutarán las líneas entre entonces y más. Estos son:

  • haciéndose eco de un mensaje de que el guión ha completado con éxito el proceso de alquitrán
  • Volviendo un código de error de 0 a fin de que la parte del código que invoca esta función sabe que todo funcionaba bien.

La porción otra cosa de esta función sólo se ejecutará si el comando tar encuentra un error durante la ejecución. En este caso, la rama else de la cláusula:

  • Echo un mensaje que indica que el comando tar no
  • devuelve un código de error de 1, lo que indica que algo ha ido mal

Por último, terminamos el entonces si / / cláusula else con una fi, que en el medio del lenguaje de bash que la cláusula si ha terminado. El

completó tarandzip () la función se verá así:

tarandzip(){
echo "n##### Gathering files #####n"
if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
echo "n##### Done gathering files #####n"
return 0
else
echo "n##### Failed to gather files #####n"
return 1
fi
}

Con nuestra función tarandzip () en su lugar, estamos listos para establecer la secuencia de comandos para mover nuestras copias de seguridad.

Transferencia de archivos al almacenamiento de objetos

En este punto, podemos conseguir nuestro script de copia de seguridad para transferir un archivo a nuestro espacio utilizando el comando s3cmd. Al igual que con tarandzip, también podemos eco de algunos hilos y luego utilizar un / if / else para mantener a los usuarios a la velocidad con la forma en la secuencia de comandos está funcionando como se está ejecutando.

En primer lugar vamos a declarar nuestra función. Vamos de nuevo mantener este sencillo y el nombre de movetoSpace ():

...
movetoSpace(){

}

Ahora podemos utilizar s3cmd y las variables que declaró anteriormente para construir el comando que impulsará nuestros archivos de copia de seguridad en nuestro espacio:

movetoSpace(){
~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST
}

Esto es lo que cada parte de este comando medios:

  • ~ / s3cmd-2.0.1 / s3cmd: Esto invoca s3cmd, una herramienta de línea de comandos utilizada para la gestión de los intervalos de almacenamiento de objetos.
  • puso: Este es un comando utilizado por s3cmd para la carga de datos en un cubo.
  • $ GIVENNAME- $ DATETIME.tar.gz: Este es el nombre de la copia de seguridad que se subirán a nuestro espacio. Se compone de las variables primero y cuarto que declaramos, seguido por .tar.gz, y es creada por la función tarandzip () de antes.
  • s3: // $ DST ;: Esta es la ubicación donde queremos subir el archivo. S3: // es un URI-como esquema utilizado específicamente para describir ubicaciones de almacenamiento de objetos en línea, mientras que el horario de verano $; es la tercera variable que declaramos anteriormente.

Ahora tenemos una función que se puede subir nuestros archivos guardados en nuestro espacio. Sin embargo, no notifica al usuario de su estado. Vamos a cambiar esta haciendo eco de una cadena antes de la orden para que el conocimiento del usuario que ha iniciado, y después de la función se ha completado, a nos permiten saber si se ha realizado correctamente. inicio de

Let notificando al usuario de que el proceso ha comenzado:

movetoSpace(){
echo “n##### MOVING TO SPACE #####n”
~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST
}

Debido a que el comando será ya sea con o sin éxito (es decir, que o bien va a subir los archivos a nuestro espacio o no será), podemos informar a los usuarios si funcionó haciendo eco de una de las dos cadenas mantenidas en una continuación / if / else, así:

...
if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
echo "n##### Done moving files to s3://"$DST" #####n"
return 0
else
echo "n##### Failed to move files to the Space #####n"
return 1
fi

esta sentencia condicional dice Bash “Si nuestras funciones de mando s3cmd correctamente, permiten el conocimiento del usuario que la escritura se hace mover archivos en nuestro espacio. De lo contrario, permiten al usuario saber que el proceso no se pudo “.

Si se completa el proceso con éxito s3cmd entonces la función imprime un mensaje en la pantalla (la primera cadena de eco en la declaración a continuación), indicando así, y devuelve un valor de 0, que informa a la función de llamar a que la operación se ha completado. Si el proceso falla, entonces la cláusula simplemente imprime el mensaje de error (la segunda cadena de eco), y devuelve un 1 por lo que el resto del guión es consciente de que ha ocurrido un error.

En total, la función movetoSpace () debe tener este aspecto:

movetoSpace(){
echo "n##### MOVING TO SPACE #####n"
if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
echo "n##### Done moving files to s3://"$DST" #####n"
return 0
else
echo "n##### Failed to move files to the Space #####n"
return 1
fi
}

Con la función movetoSpace () por escrito, podemos pasar a asegurar que el guión está configurado para funciones de llamada en el orden esperado mediante el uso de instrucciones condicionales para el flujo de controlar.

Configuración de control de flujo

Aunque hemos puesto en marcha nuestro script con las funciones, no hemos proporcionado una orden de la secuencia de comandos para completar esas funciones. En este punto, podemos introducir una función llamada que le dirá el resto de la secuencia de comandos exactamente cómo y cuándo ejecutar las otras funciones que hemos escrito.

Suponiendo que todo se ha configurado correctamente, cuando se ejecute la secuencia de comandos debe decir el comando de entrada, asignar los valores de cada variable a, realizar la función tarandzip (), y para continuar, con la función movetoSpace (). En caso de fallar el guión entre cualquiera de esos puntos, se debe imprimir la salida de nuestra función showHelp () para ayudar a los usuarios con la solución de problemas. Podemos pedir este y los errores de captura mediante la adición de una serie de If-Then / / else en la parte inferior del archivo:

...
if [ ! -z "$GIVENNAME" ]; then
if tarandzip; then
movetoSpace
else
showhelp
fi
else
showhelp
fi

La primera sentencia if no en la sección anterior comprueba que la tercera variable pasada está vacía. Y lo hace de la siguiente manera:

  • []: Los corchetes indican que lo que yace entre ellos es una prueba. En este caso, la prueba es para una variable específica a no estar vacío.
  • : En este caso, este símbolo no significa.
  • -z: Esta opción indica una cadena vacía. Así que, combinado con el!, Estamos pidiendo no es una cadena vacía.
  • $ givenname: aquí estamos indicando que la cadena no queremos estar vacío es el valor asignado a la variable $ givenname. La razón por la que elegimos este enfoque se debe a que esta variable se le asigna el valor pasado por el tercer parámetro al llamar al script desde la línea de comandos. Si pasamos menos de 3 parámetros para la secuencia de comandos, el código no tendrá un tercer parámetro para asignar el valor a $ givenname, por lo que le asignará una cadena vacía y esto prueba fallará.

Suponiendo que esta primera prueba es satisfactoria, será a continuación, pasar a la siguiente instrucción if y así sucesivamente. Si cualquiera de las sentencias if devuelve un error, entonces la cláusula llamará a la función showHelp y texto de ayuda se muestra en la representación. En esencia, lo que esto hace es que encola juntos todas las funciones anteriores que hemos escrito y da fiesta de la información que necesita para realizarlas en el orden correcto.

Nuestra escritura se ha completado! Puede verificar que su apariencia script como el guión completo que construyen en la sección de abajo.

The Complete Guión

La completado la escritura de copias de seguridad que hemos creado debería tener este aspecto:

#!/bin/bash
DATETIME=`date +%y%m%d-%H_%M_%S`
SRC=$1
DST=$2
GIVENNAME=$3
showhelp(){
echo "nn############################################"
echo "# bkupscript.sh #"
echo "############################################"
echo "nThis script will backup files/folders into a single compressed file and will store it in the current folder."
echo "In order to work, this script needs the following three parameters in the listed order: "
echo "t- The full path for the folder or file you want to backup."
echo "t- The name of the Space where you want to store the backup at (not the url, just the name)."
echo "t- The name for the backup file (timestamp will be added to the beginning of the filename)n"
echo "Example: sh bkupscript.sh .estdir testSpace backupdatan"
}
tarandzip(){
echo "n##### Gathering files #####n"
if tar -czvf $GIVENNAME-$DATETIME.tar.gz $SRC; then
echo "n##### Done gathering files #####n"
return 0
else
echo "n##### Failed to gather files #####n"
return 1
fi
}
movetoSpace(){
echo "n##### MOVING TO SPACE #####n"
if ~/s3cmd-2.0.1/s3cmd put $GIVENNAME-$DATETIME.tar.gz s3://$DST; then
echo "n##### Done moving files to s3://"$DST" #####n"
return 0
else
echo "n##### Failed to move files to the Space #####n"
return 1
fi
}
if [ ! -z "$GIVENNAME" ]; then
if tarandzip; then
movetoSpace
else
showhelp
fi
else
showhelp
fi

Una vez que haya verificado su secuencia de comandos, asegúrese de guardar y cerrar el archivo (CTRL-x, y, a continuación, ENTER) antes de salir nano .

Prueba de la escritura

Ahora que hemos terminado con la construcción de la secuencia de comandos, podemos pasar a prueba a cabo. Esto no sólo nos dirá si hemos escrito el guión correctamente, pero también nos dará la oportunidad de practicar el uso de la secuencia de comandos y verlo en acción.

Al probar un guión como este, por lo general es una buena idea utilizar archivos ficticios. A pesar de que sabemos que no es capaz de destruir o eliminar los datos, lo más inteligente es ir a lo seguro para ello, algunos archivos no importantes. primero vamos a crear un directorio con el comando mkdir:

mkdir backupthis

  • mkdir backupthis

A continuación, vamos a crear dos archivos vacíos dentro de este directorio mediante touch:

sudo touch backupthis/file1.txt
sudo touch backupthis/file2.txt

  • sudo backupthis táctiles / file1.txt sudo
  • backupthis táctiles / file2.txt

ahora podemos probar el script mediante la subida del directorio backupthis y su contenido a nuestro espacio. Este es el formato que tendrá que utilizar para invocar el script:

sh bkupscript.sh ./backupthis name_of_your_space testrun

  • sh bkupscript.sh ./backupthis name_of_your_space pequeña vuelta

Nota Dado que la función movetoSpace () automáticamente antepone s3: // al destino variable (es decir, el nombre de su espacio), esta variable debe ser simplemente el nombre de su espacio y no su URL completa. Por ejemplo, si de su espacio de direcciones URL es “https://example-space-name.nyc3.digitaloceanspaces.com”, podría escribir el comando prueba como esta:

sh bkupscript.sh ./backupthis example-space-name testrun

  • sh bkupscript.sh ./backupthis ejemplo-espacio- nombrar pequeña vuelta

el comando anterior establecerá la secuencia de comandos en movimiento y debería ver una salida como ésta:

Output
##### Gathering files #####

./backupthis/
./backupthis/file1.txt
./backupthis/file2.txt

##### Done gathering files #####

##### MOVING TO SPACE #####

upload: 'testrun-180119-15_09_36.tar.gz' -> 's3:/
ame_of_your_space estrun-180119-15_09_36.tar.gz' [1 of 1]
162 of 162 100% in 8s 19.81 B/s done

##### Done moving files to s3:/
ame_of_your_space #####

Si se produce algún error, por favor, revise la secuencia de comandos para asegurarse de que coincide con nuestro ejemplo. Además, asegúrese de que la instalación de s3cmd se ha configurado correctamente y que tanto la clave de acceso y la clave secreta que está utilizando son correctos.

Automatización de las copias de seguridad con Crontab

Después de probar con éxito el script de copias de seguridad, podemos configurar una tarea programada que utilice el script para realizar copias de seguridad periódicas en nuestro espacio. Para el propósito de este tutorial, vamos a configurarlo para ejecutar nuestro script de copias de seguridad cada minuto.

En primer lugar, tenemos que hacer el script ejecutable:

chmod +x bkupscript.sh

  • chmod + x bkupscript.sh

Ahora que la secuencia de comandos se puede ejecutar como un comando, podemos editar el archivo crontab para ejecutar el script cada minuto:

crontab -e

  • crontab -e

la primera vez que se ejecuta crontab -e, se le pedirá que seleccione un editor de una lista:

no crontab for root - using an empty one
Select an editor. To change later, run 'select-editor'.
1. /bin/ed
2. /bin
ano <---- easiest 3. /usr/bin/vim.basic 4. /usr/bin/vim.tiny Choose 1-4 [2]:

puede seleccionar el nano defecto, u otro editor de texto de su elección.

Una vez en el crontab, se añadirá la siguiente línea en la parte inferior de los valores que ya están allí:

* * * * * ~/bkupscript.sh ~/backupthis nameofyourspace cronupload

para guardar los cambios, pulse Ctrl-x, entonces y, a continuación, ENTER.

Después de un minuto o así, verá un nuevo archivo en el tablero de su espacio!

Si deja el trabajo de cron se ejecuta sin realizar ningún cambio, tendrá un nuevo archivo copiado en el espacio cada minuto. Una vez que haya confirmado que cron se ejecuta con éxito, no dude en volver a configurar el crontab para copia de seguridad de sus archivos en el intervalo deseado.

Ahora tiene un script que comprime y envía periódicamente copias de seguridad a un espacio digitalocean!

Conclusión

En este tutorial, hemos repasado cómo crear copias de seguridad fuera regulares de sus archivos importantes usando un script bash, crontab, y los espacios digitalocean. Aunque el guión presentado en este tutorial sólo se diseñó para fines de demostración, que puede ser utilizado como una base para construir una versión lista para producción que más tarde podría ser integrado con una solución CI / CD como Jenkins, aviones no tripulados, o Travis CI.

Si desea obtener más información sobre las herramientas de CI / CD, puede hacerlo mediante la lectura de los siguientes tutoriales:

  • cómo configurar Jenkins para Continuo Develompment Integración En Centos7.
  • cómo configurar continua Integración tuberías con aviones no tripulados en Ubuntu 16.04.