One place for hosting & domains

      administrar

      Cómo administrar conjuntos ordenados en Redis


      Introducción

      Redis es un almacén de datos clave-valor en memoria de código abierto. En Redis, los conjuntos ordenados son un tipo de datos similares a los conjuntos, ya que ambos son grupos de cadenas que no se repiten. La diferencia es que cada componente de un conjunto ordenado se asocia a una puntuación, lo que permite ordenarlos de la menor a la mayor. Como en el caso de los conjuntos, todos los componentes de un conjunto ordenado deben ser únicos, aunque varios pueden compartir la misma puntuación.

      En este tutorial, se explica la forma de crear conjuntos ordenados, obtener y eliminar sus componentes y crear nuevos conjuntos ordenados a partir de conjuntos existentes.

      Cómo usar esta guía

      Esta guía está escrita a modo de ayuda memoria con ejemplos independientes. Lo alentamos a ir directamente a cualquier sección que sea pertinente para la tarea que desee completar.

      Los comandos que se muestran en esta guía se probaron en un servidor de Ubuntu 18.04 con Redis 4.0.9. Para configurar un entorno similar, puede seguir el paso 1 de nuestra guía Cómo instalar y proteger Redis en Ubuntu 18.04. Mostraremos el comportamiento de estos comandos ejecutándolos con redis-cli, la interfaz de línea de comandos de Redis. Tenga en cuenta que si utiliza una interfaz de Redis diferente (por ejemplo, Redli), el resultado exacto de algunos comandos puede diferir.

      De forma alternativa, podría proporcionar una instancia de base de datos de Redis gestionada para probar estos comandos, pero tenga en cuenta que, dependiendo del nivel de control que permita su proveedor de base de datos, es posible que algunos comandos de esta guía no funcionen según lo descrito.  Para proporcionar una base de datos gestionada de DigitalOcean, consulte nuestra documentación sobre bases de datos gestionadas. Luego, debe instalar Redli o configurar un túnel TLS para establecer conexión con la base de datos gestionada mediante TLS.

      Crear conjuntos ordenados y añadir componentes

      Para crear un conjunto ordenado, utilice el comando zadd. zadd acepta como argumento el nombre de la clave que contendrá el conjunto ordenado, seguido de la puntuación del componente que añada y el valor del propio componente. Con el siguiente comando, se creará una clave de conjunto ordenado denominada faveGuitarists con un componente, "Joe Pass", que tiene una puntuación de 1:

      • zadd faveGuitarists 1 "Joe Pass"

      zadd mostrará un entero que indica la cantidad de componentes añadidos al conjunto ordenado si se creó de forma correcta.

      Output

      (integer) 1

      Puede añadir más de un componente a un conjunto ordenado con zadd. Tenga en cuenta que no es necesario que las puntuaciones sean secuenciales; puede haber brechas entre ellas, y varios componentes de un mismo conjunto ordenado pueden compartir la misma puntuación:

      • zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

      Output

      (integer) 8

      zadd puede aceptar las siguientes opciones, que debe ingresar después del nombre de clave y antes de la puntuación del primer componente:

      • NX o XX: estas opciones tienen efectos opuestos. Por lo tanto, solo puede incluir una de ellas en cualquier operación de zadd:
        • NX: indica a zadd que no actualice componentes existentes. Con esta opción, zadd añadirá únicamente elementos nuevos.
        • XX: indica a zadd a que solo actualice elementos existentes. Con esta opción, zadd nunca añadirá nuevos componentes.
      • CH: en general, zadd solo muestra la cantidad de nuevos elementos añadidos al conjunto ordenado. Con esta opción, sin embargo, zadd mostrará la cantidad de elementos modificados. Esto comprende los componentes recientemente añadidos y aquellos cuya puntuación se modificó.
      • INCR: hace que el comando aumente el valor de la puntuación del componente. Si el componente todavía no existe, el comando lo añadirá al conjunto ordenado con el aumento como puntuación, como si la puntuación original hubiera sido 0. Con INCR incluido, zadd muestra la puntuación nueva del componente si es correcta. Tenga en cuenta que solo puede incluir una puntuación o un componente a la vez cuando se utiliza esta opción.

      En lugar de pasar la opción INCR a zadd, puede usar el comando zincrby, que se comporta exactamente de la misma manera. En vez de dar al componente del conjunto ordenado el valor que indica la puntuación como zadd, aplica a la puntuación del componente un incremento equivalente a ese valor.  Por ejemplo, con el siguiente comando se aplica un incremento de 5 a la puntuación del componente "Stephen Malkmus", que originalmente era 4, con lo cual llega a 9.

      • zincrby faveGuitarists 5 "Stephen Malkmus"

      Output

      "9"

      Como en el caso de la opción INCR del comando zadd, si el componente especificado no existe, zincrby lo crea con el valor de incremento como puntuación.

      Obtener componentes de conjuntos ordenados

      La manera más básica de recuperar componentes de un conjunto ordenado es usar el comando zrange.  Este comando acepta como argumento el nombre de la clave cuyos componentes desea obtener y un intervalo de componentes que se encuentran en su interior. El intervalo está definido por dos números que representan índices basados en cero, lo cual significa que 0 representa el primer componente del conjunto ordenado (o el componente con la puntuación más baja), 1 el siguiente y así sucesivamente.

      En el siguiente ejemplo, se mostrarán los primeros cuatro componentes del conjunto ordenado faveGuitarists creado en la sección anterior:

      • zrange faveGuitarists 0 3

      Output

      1) "Joe Pass" 2) "Rosetta Tharpe" 3) "Bola Sete" 4) "Doug Martsch"

      Tenga en cuenta que si el conjunto ordenado que pasa a zrange tiene dos o más elementos con la misma puntuación, les aplicará orden lexicográfico o alfabético.

      Los índices de inicio y detención también pueden ser números negativos: -1 representa el último componente, -2 el penúltimo y así sucesivamente.

      • zrange faveGuitarists -5 -2

      Output

      1) "Memphis Minnie" 2) "Elizabeth Cotten" 3) "Stephen Malkmus" 4) "Michael Houser"

      zrange puede aceptar el argumento WITHSCORES que, cuando se incluya, también mostrará las puntuaciones de los componentes:

      • zrange faveGuitarists 5 6 WITHSCORES

      Output

      1) "Elizabeth Cotten" 2) "8" 3) "Stephen Malkmus" 4) "9"

      zrange solo puede mostrar un intervalo de componentes en orden numérico ascendente. Para revertir esto y mostrar un intervalo en orden decreciente, debe usar el comando zrevrange. Considere este comando como una reversión temporal del ordenamiento del conjunto ordenado dado antes de mostrar los componentes que se encuentran dentro del intervalo especificado. Como sucede con zrevrange, 0 representará el último componente de la clave, 1 el penúltimo y así sucesivamente:

      • zrevrange faveGuitarists 0 5

      Output

      1) "Nancy Wilson" 2) "Michael Houser" 3) "Stephen Malkmus" 4) "Elizabeth Cotten" 5) "Memphis Minnie" 6) "Doug Martsch"

      zrevrange también puede aceptar la opción WITHSCORES.

      Puede mostrar un intervalo de componentes según sus puntuaciones con el comando zrangebyscore. En el siguiente ejemplo, con el comando se mostrará cualquier componente que se encuentre en la clave faveGuitarists con una puntuación de 2, 3, o 4:

      • zrangebyscore faveGuitarists 2 4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch" 4) "Memphis Minnie"

      En este ejemplo, el intervalo es inclusivo, lo cual significa que mostrará componentes con puntuaciones de 2 o 4. Puede excluir cualquier extremo del intervalo anteponiéndole un paréntesis abierto ((). En el siguiente ejemplo, se mostrarán todos los componentes con una puntuación superior o igual a 2, pero inferior a 4:

      • zrangebyscore faveGuitarists 2 (4

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Al igual que zrange, zrangebyscore puede aceptar el argumento WITHSCORES. También acepta la opción LIMIT, que puede usar para obtener solo una selección de elementos del resultado de zrangebyscore. Esta opción acepta un desplazamiento, que indica el primer componente del intervalo que se mostrará con el comando y un recuento que define la cantidad total de componentes que se mostrarán con el comando. Por ejemplo, con el siguiente comando se analizarán los primeros seis componentes del conjunto ordenado faveGuitarists, pero solo se mostrarán 3 componentes de él, a partir del segundo componente del intervalo, representado por 1:

      • zrangebyscore faveGuitarists 0 5 LIMIT 1 3

      Output

      1) "Rosetta Tharpe" 2) "Bola Sete" 3) "Doug Martsch"

      Con el comando zrevrangebyscore, se muestra un intervalo invertido de componentes según sus puntuaciones. Con el siguiente comando se muestran todos los componentes del conjunto con una puntuación de entre 10 y 6:

      • zrevrangebyscore faveGuitarists 10 6

      Output

      1) "Stephen Malkmus" 2) "Elizabeth Cotten"

      Al igual que zrangebyscore, zrangebyscore puede aceptar las opciones WITHSCORES y LIMIT. Además, puede excluir cualquier extremo del intervalo anteponiéndole un paréntesis abierto.

      Puede haber momentos en que todos los componentes de un conjunto ordenado tengan la misma puntuación. En ese caso, puede hacer que Redis muestre de forma forzosa un intervalo de elementos en orden lexicográfico o alfabético con el comando zrangebylex. Para probar este comando, ejecute el siguiente comando zadd a fin de crear un conjunto ordenado en el que cada componente tenga la misma puntuación:

      • zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

      zrangebylex debe ir seguido del nombre de una clave, un intervalo de inicio y un intervalo de detención. Los intervalos de inicio y detención deben iniciarse con un paréntesis abierto (() o un corchete abierto ([), como se muestra a continuación:

      • zrangebylex SomervilleSquares [a [z

      Output

      1) "assembly" 2) "ball" 3) "magoun" 4) "porter"

      Tenga en cuenta que en este ejemplo solo se mostraron cuatro de los ocho componentes del conjunto, a pesar de que el comando buscaba un intervalo de la a a la z. Esto se debe a que los valores de Redis distinguen entre mayúsculas y minúsculas; por lo tanto, los componentes que comienzan con letras mayúsculas se excluyeron de su resultado. Para mostrarlos, puede ejecutar lo siguiente:

      • zrangebylex SomervilleSquares [A [z

      Output

      1) "Davis" 2) "Inman" 3) "Union" 4) "assembly" 5) "ball" 6) "magoun" 7) "porter"

      zrangebylex también acepta los caracteres especiales -, que representa un infinito negativo y +, que representa un infinito positivo. Por lo tanto, con la siguiente sintaxis de comando también se mostrarán todos los componentes del conjunto ordenado:

      • zrangebylex SomervilleSquares - +

      Tenga en cuenta que zrangebylex no puede mostrar componentes del conjunto en orden lexicográfico inverso (alfabético ascendente). Para hacerlo, utilice zrevrangebylex:

      • zrevrangebylex SomervilleSquares + -

      Output

      1) "porter" 2) "magoun" 3) "ball" 4) "assembly" 5) "Union" 6) "Inman" 7) "Davis"

      Debido a que está destinado a usarse con conjuntos ordenados en los que todos los componentes tienen la misma puntuación, zrangebylex no acepta la opción WITHSCORES.  Sin embargo, sí acepta la opción LIMIT.

      Obtener información sobre conjuntos ordenados

      Para averiguar la cantidad de componentes de un conjunto ordenado determinado (o, en otras palabras, su cardinalidad), utilice el comando zcard. En el siguiente ejemplo, se muestra la cantidad de componentes contenidos en la clave faveGuitarists de la primera sección de esta guía:

      Output

      (integer) 9

      zcount puede indicar la cantidad de elementos de un conjunto ordenado determinado que se encuentran dentro de un intervalo de puntuaciones. El primer número que sigue a la clave es el comienzo del intervalo y el segundo es el final:

      • zcount faveGuitarists 3 8

      Output

      (integer) 4

      zscore obtiene la puntuación de un componente especificado de un conjunto ordenado:

      • zscore faveGuitarists "Bola Sete"

      Output

      "3"

      Si el componente o la clave especificados no existen, zscore mostrará (nil).

      zrank es similar a zscore, pero, en vez de mostrar la puntuación del componente determinado, muestra su clasificación. En Redis, una clasificación es un índice basado en cero de los componentes de un conjunto ordenado por su puntuación. Por ejemplo, "Joe Pass" tiene una puntuación de 1, pero, dado que esa es la puntuación más baja de todos los componentes de la clave, tiene una clasificación de 0:

      • zrank faveGuitarists "Joe Pass"

      Output

      (integer) 0

      Hay otro comando de Redis denominado zrevrank que realiza la misma función que zrank, pero, en su lugar, invierte las clasificaciones de los componentes del conjunto. En el siguiente ejemplo, el componente "Joe Pass" tiene la puntuación más baja y, por lo tanto, la clasificación invertida más alta:

      • zrevrank faveGuitarists "Joe Pass"

      Output

      (integer) 8

      La única relación entre la puntuación de un componente y su clasificación es la posición que ocupa su puntuación en relación con las de otros miembros.  Si hay una brecha de puntuación entre dos componentes secuenciales, no se reflejará en su clasificación. Tenga en cuenta que si dos componentes tienen la misma puntuación, el primero en orden alfabético tendrá la menor clasificación.

      Al igual que zscore, zrank y zrevrank devolverán (nil) si la clave o el componente no existen.

      zlexcount puede indicar la cantidad de componentes que se encuentran en un conjunto ordenado en un intervalo lexicográfico. En el siguiente ejemplo, se utiliza el conjunto ordenado SomervilleSquares de la sección anterior:

      • zlexcount SomervilleSquares [M [t

      Output

      (integer) 5

      Este comando tiene la misma sintaxis que zrangebylex. Por lo tanto, consulte la sección anterior para obtener información detallada sobre cómo definir un intervalo de cadena.

      Eliminar componentes de conjuntos ordenados

      Con el comando zrem, es posible eliminar uno o más componentes de un conjunto ordenado:

      • zrem faveGuitarists "Doug Martsch" "Bola Sete"

      zrem mostrará un entero que indicará la cantidad de componentes que eliminó del conjunto ordenado:

      Output

      (integer) 2

      Hay tres comandos de Redis que le permiten eliminar componentes de un conjunto ordenado basado en un intervalo. Por ejemplo, si todos los componentes de un conjunto ordenado tienen la misma puntuación, puede eliminar componentes sobre la base de un intervalo lexicográfico con zremrangebylex. Este comando utiliza la misma sintaxis que zrangebylex. En el siguiente ejemplo, se eliminarán de la clave SomervilleSquares creada en la sección anterior todos los componentes que comiencen con una letra mayúscula :

      • zremrangebylex SomervilleSquares [A [Z

      zremrangebylex dará como resultado un entero que indica la cantidad de componentes que eliminó:

      Output

      (integer) 3

      También puede eliminar componentes en base a un intervalo de puntuaciones con el comando zremrangebyscore, que utiliza la misma sintaxis que el comando zrangebyscore. En el siguiente ejemplo, se eliminarán todos los componentes de faveGuitarists con una puntuación de 4, 5 o 6:

      • zremrangebyscore faveGuitarists 4 6

      Output

      (integer) 1

      Puede eliminar componentes de un conjunto en base a un intervalo de clasificaciones con el comando zremrangebyrank, que utiliza la misma sintaxis que zrangebyrank. Con el siguiente comando, se eliminarán los tres componentes del conjunto ordenado con las clasificaciones más bajas, que se definen en función de un intervalo de índices basados en cero:

      • zremrangebyrank faveGuitarists 0 2

      Output

      (integer) 3

      Tenga en cuenta que los números que se pasan a remrangebyrank también pueden ser negativos: -1 representa la clasificación más alta, -2 la siguiente y así sucesivamente.

      Crear nuevos conjuntos ordenados a partir de conjuntos existentes

      Redis incluye dos comandos que le permiten comparar componentes de varios conjuntos ordenados y crear conjuntos nuevos sobre la base de esas comparaciones: estos son zinterstore y zunionstore. Para experimentar con ellos, ejecute los siguientes comandos zadd a fin de crear conjuntos ordenados de ejemplo.

      • zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
      • zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

      zinterstore encuentra los componentes que comparten dos o más conjuntos ordenados (en su intersección) y produce un nuevo conjunto ordenado que contiene únicamente estos componentes. Este comando debe incluir, en orden, el nombre de una clave de destino en la que los componentes de la intersección se almacenarán como conjunto ordenado, el número de claves que se pasan a zinterstore y los nombres de las claves que desea analizar:

      • zinterstore BoyBands 2 NewKids Nsync

      zinterstore mostrará un entero que indica la cantidad de elementos almacenados en el conjunto ordenado de destino. Debido a que NewKids y Nsync solo comparten un componente, "Joey", el comando mostrará 1:

      Output

      (integer) 1

      Tenga en cuenta que si la clave de destino ya existe, zinterstore sobrescribirá su contenido.

      zunionstore creará un nuevo conjunto ordenado que contendrá todos los componentes de las claves que se le pasaron. Este comando utiliza la misma sintaxis que zinterstore y requiere el nombre de una clave de destino, la cantidad de claves que se pasan al comando y los nombres de estas:

      • zunionstore SuperGroup 2 NewKids Nsync

      Al igual que zinterstore, zunionstore , mostrará un entero que indica la cantidad de elementos almacenados en la clave de destino. Si bien los dos conjuntos ordenados originales tienen cinco componentes, dado que los conjuntos ordenados no pueden tener componentes repetidos y cada clave tiene un componente denominado "Joey", el entero resultante será 9:

      Output

      (integer) 9

      Al igual que zinterstore, zunionstore sobrescribirá el contenido de la clave de destino si ya existe.

      Para tener más control sobre las puntuaciones de los componentes al crear conjuntos ordenados nuevos con zinterstore y zunionstore, los dos comandos aceptan las opciones WEIGHTS y AGGREGATE.

      La opción WEIGHTS va seguida de un número por cada conjunto ordenado incluido en el comando que pondera o multiplica la puntuación de cada componente. El primer número después de la opción WEIGHTS pondera las puntuaciones de la primera clave que se pasó al comando, el segundo número pondera la segunda y así sucesivamente.

      En el siguiente ejemplo, se crea un nuevo conjunto ordenado que contiene las claves intersecantes de los conjuntos ordenados NewKids y Nsync. Pondera las puntuaciones de la clave de NewKids en un factor de tres y las de la clave de Nsync en un factor de siete:

      • zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

      Si la opción WEIGHTS no se incluye, la ponderación por defecto es 1 tanto para zinterstore como para zunionstore.

      AGGREGATE acepta tres subopciones. La primera, SUM, implementa el comportamiento predeterminado de zinterstore y zunionstore añadiendo las puntuaciones de los componentes coincidentes en los conjuntos combinados.

      Si ejecuta una operación zinterstore o zunionstore en dos conjuntos ordenados que comparten un componente, pero este tiene una puntuación diferente en cada conjunto, puede hacer que la operación asigne por la fuerza la menor de las dos puntuaciones en el nuevo conjunto con la subopción MIN.

      • zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

      Debido a que los dos conjuntos ordenados solo tienen un componente coincidente con la misma puntuación (3), este comando creará un nuevo conjunto con el componente que tenga la menor de las dos puntuaciones ponderadas:

      • zscore BoyBandsWeightedMin "Joey"

      Output

      "9"

      De la misma manera, AGGREGATE puede forzar zinterstore o zunionstore a asignar la mayor de las dos puntuaciones con la opción MAX:

      • zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

      A través de este comando, se crea un nuevo conjunto con un componente, "Joey", que tiene la mayor de las dos puntuaciones ponderadas.

      • zscore BoyBandsWeightedMax "Joey"

      Output

      "21"

      Puede ser útil considerar a WEIGHTS como una alternativa para manipular las puntuaciones de los componentes temporalmente antes de que se analicen. De la misma manera, es útil concebir a la opción AGGREGATE como una opción para decidir cómo controlar las puntuaciones de los componentes antes de añadirlos a sus nuevos conjuntos.

      Conclusión

      En esta guía, se detallan varios comandos que se utilizan para crear y administrar conjuntos ordenados en Redis. Si desea ver en esta guía descripciones de otros comandos, argumentos o procedimientos relacionados, deje sus solicitudes o sugerencias en la sección de comentarios a continuación.

      Para obtener más información sobre los comandos de Redis, consulte nuestra serie de tutoriales Cómo administrar bases de datos de Redis.



      Source link

      Cómo administrar y usar activadores de bases de datos de MySQL en Ubuntu 18.04


      El autor seleccionó la Apache Software Foundation para recibir una donación como parte del programa Write for DOnations.

      Introducción

      En MySQL, un activador es un comando SQL definido por el usuario que se invoca automáticamente durante una operación INSERT, DELETE o UPDATE. El código de activación se asocia con una tabla y se destruye una vez que se elimina una tabla. Puede especificar un tiempo de acción de activación y establecer si esta se producirá antes o después del evento de base de datos definido.

      Los activadores tienen varias ventajas. Por ejemplo, puede usarlos para generar el valor de una columna derivada durante una instrucción INSERT. Otro caso de uso tiene que ver con la aplicación de la integridad referencial, en el que puede usar un activador para guardar un registro en varias tablas relacionadas. Entre otras ventajas, se incluyen el registro de las acciones del usuario para realizar una auditoría de las tablas, así como la copia en vivo de datos en diferentes esquemas de bases de datos por motivos de redundancia para evitar un único punto de fallo.

      También puede usar activadores para mantener las reglas de validación en el nivel de base de datos. Esto le permite compartir la fuente de datos en varias aplicaciones sin infringir la lógica de negocios. Con esto, se reducen en gran medida los recorridos de ida y vuelta al servidor de base de datos, lo cual a su vez mejora el tiempo de respuesta de sus aplicaciones. Debido a que en el servidor de base de datos se ejecutan activadores, se pueden aprovechar recursos mejorados de este, como la memoria RAM y el CPU.

      En este tutorial, creará, usará y eliminará diferentes tipos de activadores en su base de datos de MySQL.

      Requisitos previos

      Antes de comenzar, asegúrese de contar con lo siguiente:

      Paso 1: Crear una base de datos de ejemplo

      En este paso, creará una base de datos de clientes de ejemplo con varias tablas para demostrar el funcionamiento de los activadores de MySQL.

      Para obtener más información sobre consultas de MySQL, lea nuestra Introducción a las consultas de MySQL.

      Primero, inicie sesión en su servidor MySQL como root:

      Introduzca su contraseña root de MySQL cuando se le solicite y presione INTRO para continuar. Cuando visualice el intérprete de comandos de mysql>, ejecute el siguiente comando para crear una base de datos test_db:

      Output

      Query OK, 1 row affected (0.00 sec)

      A continuación, realice un cambio a test_db con lo siguiente:

      Output

      Database changed

      Comience creando una tabla customers. En esta tabla se almacenarán los registros de los clientes, incluidos customer_id, customer_name y level. Habrá dos niveles de cliente: BASIC y VIP.

      • Create table customers(customer_id BIGINT PRIMARY KEY, customer_name VARCHAR(50), level VARCHAR(50) ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      Ahora, añada algunos registros a la tabla customers. Para hacer esto, ejecute los siguientes comandos uno por uno:

      • Insert into customers (customer_id, customer_name, level )values('1','JOHN DOE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('2','MARY ROE','BASIC');
      • Insert into customers (customer_id, customer_name, level )values('3','JOHN DOE','VIP');

      Verá el siguiente resultado después de ejecutar cada uno de los comandos INSERT:

      Output

      Query OK, 1 row affected (0.01 sec)

      Para asegurarse de que los registros de ejemplo se hayan insertado correctamente, ejecute el comando SELECT:

      Output

      +-------------+---------------+-------+ | customer_id | customer_name | level | +-------------+---------------+-------+ | 1 | JOHN DOE | BASIC | | 2 | MARY ROE | BASIC | | 3 | JOHN DOE | VIP | +-------------+---------------+-------+ 3 rows in set (0.00 sec)

      También creará otra tabla para contener información relacionada con la cuenta customers. Esta tabla contendrá un campo customer_id y un campo status_notes.

      Ejecute el siguiente comando:

      • Create table customer_status(customer_id BIGINT PRIMARY KEY, status_notes VARCHAR(50)) ENGINE=INNODB;

      A continuación, creará una tabla sales. En esta tabla, se almacenarán datos de ventas relacionados con los diferentes clientes a través de la columna customer_id:

      • Create table sales(sales_id BIGINT PRIMARY KEY, customer_id BIGINT, sales_amount DOUBLE ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.01 sec)

      En los próximos pasos, añadirá datos de ejemplo a los de sales mientras prueba los activadores. A continuación, cree una tabla audit_log para registrar las actualizaciones realizadas en la tabla sales cuando implemente el activador AFTER UPDATE en el paso 5:

      • Create table audit_log(log_id BIGINT PRIMARY KEY AUTO_INCREMENT, sales_id BIGINT, previous_amount DOUBLE, new_amount DOUBLE, updated_by VARCHAR(50), updated_on DATETIME ) ENGINE=INNODB;

      Output

      Query OK, 0 rows affected (0.02 sec)

      Una vez establecidas la base de datos test_db y las cuatro tablas, procederá a trabajar con los diferentes activadores de MySQL en su base de datos.

      Paso 2: Crear un activador “Before Insert”

      En este paso, examinará la sintaxis de un activador de MySQL antes de aplicar esta lógica para crear un activador BEFORE INSERT que valide el campo sales_amount cuando se inserten datos en la tabla sales.

      La sintaxis general para crear un activador de MySQL se muestra en el siguiente ejemplo:

      DELIMITER //
      CREATE TRIGGER [TRIGGER_NAME]
      [TRIGGER TIME] [TRIGGER EVENT]
      ON [TABLE]
      FOR EACH ROW
      [TRIGGER BODY]//
      DELIMITER ;
      

      En la estructura del activador se incluye lo siguiente:

      DELIMITER //: el delimitador predeterminado de MySQL es ;, es necesario cambiarlo por algo diferente para que MySQL trate las siguientes líneas como un comando hasta que alcance su delimitador personalizado. En este ejemplo, el delimitador se cambió a // y luego al final se redefinió el delimitador ;.

      [TRIGGER_NAME]: un activador debe contar con un nombre y aquí es donde debe incluir el valor.

      [TRIGGER TIME]: un activador se puede invocar en diferentes intervalos. En MySQL se le permite definir si el activador se iniciará antes o después de una operación de base de datos.

      [TRIGGER EVENT]: los activadores solo se pueden invocar con operaciones INSERT, UPDATE y DELETE. Aquí puede usar cualquier valor dependiendo de lo que quiera lograr.

      [TABLE]: cualquier activador que cree en su base de datos de MySQL debe estar asociado a una tabla.

      FOR EACH ROW: con esta instrucción se ordena a MySQL ejecutar el código de activación para cada fila afectada por el activador.

      [TRIGGER BODY]: el código que se ejecuta cuando se invoca el activador se conoce como cuerpo del activador. Puede constar de una sola instrucción SQL o de varios comandos. Tenga en cuenta que si ejecuta varias instrucciones SQL en el cuerpo del activador, debe ajustarlas entre un bloque BEGIN... END.

      Nota: Cuando cree el cuerpo del activador, puede usar las palabras claves OLD y NEW para acceder a los valores antiguos y nuevos de la columna introducidos durante una operación INSERT, UPDATE, y DELETE. En un activador DELETE, solo se puede emplear la palabra clave OLD (que usará en el paso 4).

      Ahora, creará su primer activador BEFORE INSERT. Este activador estará asociado con la tabla sales y se invocará antes de que se inserte un registro para validar sales_amount. La función del activador es verificar si el campo sales_amount que se inserta en la tabla “sales” es mayor que 10000 y mostrar un error si esto se evalúa a “true”.

      Asegúrese de haber iniciado sesión en el servidor de MySQL. Luego, introduzca los siguientes comandos MySQL uno por uno:

      • DELIMITER //
      • CREATE TRIGGER validate_sales_amount
      • BEFORE INSERT
      • ON sales
      • FOR EACH ROW
      • IF NEW.sales_amount>10000 THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      • END IF//
      • DELIMITER ;

      Usará la instrucción IF...THEN...END IF para evaluar si la cantidad que se proporciona durante la instrucción INSERT se encuentra dentro de su rango. Con el activador se puede extraer el nuevo valor sales_amount proporcionado con la palabra clave NEW.

      Para mostrar un mensaje de error genérico, utilice las siguientes líneas a fin de informar al usuario sobre el error:

      SIGNAL SQLSTATE '45000'
      SET MESSAGE_TEXT = 'Sale has exceeded the allowed amount of 10000.';
      

      A continuación, inserte un registro con un sales_amount de 11000 en la tabla sales para verificar si con el activador se detendrá la operación:

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','11000');

      Output

      ERROR 1644 (45000): Sale has exceeded the allowed amount of 10000.

      Este error muestra que el código de activación funciona según lo previsto.

      Ahora, pruebe un nuevo registro con un valor de 7500 para verificar si el comando tendrá éxito:

      • Insert into sales(sales_id, customer_id, sales_amount) values('1','1','7500');

      Debido a que el valor se encuentra dentro del rango recomendado, verá el siguiente resultado:

      Output

      Query OK, 1 row affected (0.01 sec)

      Para confirmar que se insertaron los datos, ejecute el siguiente comando:

      En el resultado, se confirma que los datos se encuentran en la tabla:

      Output

      +----------+-------------+--------------+ | sales_id | customer_id | sales_amount | +----------+-------------+--------------+ | 1 | 1 | 7500 | +----------+-------------+--------------+ 1 row in set (0.00 sec)

      En este paso, probó activadores para validar datos antes de su inserción en una base de datos.

      A continuación, trabajará con el activador AFTER INSERT para guardar información relacionada en diferentes tablas.

      Paso 3: Crear un activador “After Insert”

      Los activadores AFTER INSERT se ejecutan cuando se insertan registros correctamente en una tabla. Esta funcionalidad puede utilizarse para ejecutar automáticamente otras lógicas relacionadas con los negocios. Por ejemplo, en una aplicación bancaria, con un activador AFTER INSERT se puede cerrar una cuenta de préstamo cuando un cliente termina de pagarlo. El activador puede controlar todos los pagos introducidos en una tabla de transacciones y cerrar el préstamo automáticamente una vez que el saldo llegue a cero.

      En este paso, trabajará con su tabla customer_status usando un activador AFTER INSERT para ingresar registros de clientes relacionados.

      Para crear el activador AFTER INSERT, introduzca los siguientes comandos:

      • DELIMITER //
      • CREATE TRIGGER customer_status_records
      • AFTER INSERT
      • ON customers
      • FOR EACH ROW
      • Insert into customer_status(customer_id, status_notes) VALUES(NEW.customer_id, 'ACCOUNT OPENED SUCCESSFULLY')//
      • DELIMITER ;

      Output

      Query OK, 0 rows affected (0.00 sec)

      Aquí, indica que MySQL guarde otro registro en la tabla customer_status una vez que se inserte un nuevo registro de cliente en la tabla customers.

      Ahora, inserte un nuevo registro en la tabla customers para confirmar que se invocará su código de activación.

      • Insert into customers (customer_id, customer_name, level )values('4','DAVID DOE','VIP');

      Output

      Query OK, 1 row affected (0.01 sec)

      Debido a que el registro se insertó correctamente, compruebe que se haya introducido un nuevo registro de estado en la tabla customer_status:

      • Select * from customer_status;

      Output

      +-------------+-----------------------------+ | customer_id | status_notes | +-------------+-----------------------------+ | 4 | ACCOUNT OPENED SUCCESSFULLY | +-------------+-----------------------------+ 1 row in set (0.00 sec)

      En el resultado se confirma que el activador se ejecutó correctamente.

      El activador AFTER INSERT es útil para controlar el ciclo de vida de un cliente. En un entorno de producción, las cuentas de los clientes pueden atravesar diferentes etapas, como la apertura, la suspensión y el cierre.

      En los siguientes pasos, trabajará con activadores UPDATE.

      Paso 4: Crear un activador “Before Update”

      Los activadores BEFORE UPDATE son similares a los BEFORE INSERT; la diferencia radica en el momento en que se invocan. Puede usar el activador BEFORE UPDATE para verificar una lógica de negocios antes de que se actualice un registro. Para probar esto, usará la tabla customers en la que ya insertó datos.

      Dispone de dos niveles para sus clientes en la base de datos. En este ejemplo, una vez que la cuenta de un cliente asciende al nivel VIP, ya no es posible que descienda al nivel BASIC. Para aplicar tal regla, creará un activador BEFORE UPDATE que se ejecutará antes de la instrucción UPDATE, como se muestra a continuación. Si un usuario de la base de datos intenta hacer que un cliente descienda al nivel BASIC desde el nivel VIP, se activará una excepción definida por el usuario.

      Introduzca los siguientes comandos SQL uno por uno para crear el activador BEFORE UPDATE:

      • DELIMITER //
      • CREATE TRIGGER validate_customer_level
      • BEFORE UPDATE
      • ON customers
      • FOR EACH ROW
      • IF OLD.level='VIP' THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'A VIP customer can not be downgraded.';
      • END IF //
      • DELIMITER ;

      Utilice la palabra clave OLD para capturar el nivel que el usuario proporciona cuando ejecuta el comando UPDATE. Una vez más, utilice la instrucción IF...THEN…END IF“ para indicar una instrucción de error genérico al usuario.

      Luego, ejecute el siguiente comando SQL con el que se intenta bajar el nivel de la cuenta de un usuario asociado con el customer_id de 3:

      • Update customers set level='BASIC' where customer_id='3';

      Verá el siguiente resultado, en el que se muestra SET MESSAGE_TEXT:

      Output

      ERROR 1644 (45000): A VIP customer can not be downgraded.

      Si ejecuta el mismo comando en un cliente de nivel BASIC e intenta que la cuenta ascienda al nivel VIP, el comando se ejecutará correctamente:

      • Update customers set level='VIP' where customer_id='1';

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Usó el activador BEFORE UPDATE para implementar una regla comercial. Ahora, usará un activador AFTER UPDATE para registros de auditoría.

      Paso 5: Crear un activador “After Update”

      Un activador AFTER UPDATE se invoca una vez que se actualiza correctamente el registro de una base de datos. Este comportamiento hace que el activador sea adecuado para los registros de auditoría. En un entorno multiusuario, es posible que el administrador quiera ver el historial de los usuarios que actualizan registros en una tabla en particular para auditorías.

      Creará un activador que registre la actividad de actualización de la tabla sales. Nuestra tabla audit_log contendrá información sobre los usuarios de MySQL que actualicen la tabla sales, la date de la actualización y los valores sales_amount de new y old.

      Para crear el activador, ejecute los siguientes comandos SQL:

      • DELIMITER //
      • CREATE TRIGGER log_sales_updates
      • AFTER UPDATE
      • ON sales
      • FOR EACH ROW
      • Insert into audit_log(sales_id, previous_amount, new_amount, updated_by, updated_on) VALUES (NEW.sales_id,OLD.sales_amount, NEW.sales_amount,(SELECT USER()), NOW() )//
      • DELIMITER ;

      Se ingresa un nuevo registro en la tabla audit_log. Utilice la palabra clave NEW para obtener el valor de sales_id y el nuevo sales_amount. Además, utilice la palabra clave OLD para obtener el sales_amount anterior, ya que desea registrar ambos montos para auditoría.

      Con el comando SELECT USER() se obtiene el usuario actual que realiza la operación y con la instrucción NOW() se obtiene el valor de la fecha y hora actuales del servidor de MySQL.

      Si ahora un usuario intenta actualizar el valor de cualquier registro en la tabla sales, el activador log_sales_updates insertará un nuevo registro en la tabla audit_log.

      Crearemos un nuevo registro de ventas con un sales_id aleatorio de 5 e intentaremos actualizarlo. Primero, inserte el registro de ventas con lo siguiente:

      • Insert into sales(sales_id, customer_id, sales_amount) values('5', '2','8000');

      Output

      Query OK, 1 row affected (0.00 sec)

      A continuación, actualice el registro:

      • Update sales set sales_amount='9000' where sales_id='5';

      Verá el siguiente resultado:

      Output

      Rows matched: 1 Changed: 1 Warnings: 0

      Ahora ejecute el siguiente comando para verificar si con el activador AFTER UPDATE se pudo introducir un nuevo registro en la tabla audit_log:

      En el activador se registró la actualización. En el resultado se muestran el sales_amount y el new amount anteriores registrados con el usuario que actualizó los registros:

      Output

      +--------+----------+-----------------+------------+----------------+---------------------+ | log_id | sales_id | previous_amount | new_amount | updated_by | updated_on | +--------+----------+-----------------+------------+----------------+---------------------+ | 1 | 5 | 8000 | 9000 | root@localhost | 2019-11-07 09:28:36 | +--------+----------+-----------------+------------+----------------+---------------------+ 1 row in set (0.00 sec)

      También dispone de la fecha y hora en las que se realizó la actualización, que son valiosas para auditorías.

      A continuación, usará el activador DELETE para aplicar la integridad referencial a nivel de base de datos.

      Paso 6: Crear un activador “Before Delete”

      Los activadores BEFORE DELETE se invocan antes de que se ejecute una instrucción DELETE en una tabla. Estos tipos de activadores normalmente se utilizan para implementar la integridad referencial en diferentes tablas relacionadas. Por ejemplo, cada registro de la tabla sales se relaciona a un customer_id de la tabla customers. Si un usuario de la base de datos eliminara un registro de la tabla customers que tiene un registro relacionado en la tabla sales, usted no tendría manera de conocer al cliente asociado a ese registro.

      A fin de evitar esto, puede crear un activador BEFORE DELETE para aplicar su lógica. Ejecute los siguientes comandos SQL uno por uno:

      • DELIMITER //
      • CREATE TRIGGER validate_related_records
      • BEFORE DELETE
      • ON customers
      • FOR EACH ROW
      • IF OLD.customer_id in (select customer_id from sales) THEN
      • SIGNAL SQLSTATE '45000'
      • SET MESSAGE_TEXT = 'The customer has a related sales record.';
      • END IF//
      • DELIMITER ;

      Ahora, intente eliminar un cliente que tenga un registro de ventas relacionado:

      • Delete from customers where customer_id='2';

      Como resultado, obtendrá lo siguiente:

      Output

      ERROR 1644 (45000): The customer has a related sales record.

      Con el activador BEFORE DELETE se puede evitar la eliminación accidental de información relacionada en una base de datos.

      Sin embargo, en algunas situaciones, es posible que quiera eliminar todos los registros asociados con un registro específico de las diferentes tablas relacionadas. En este caso, usaría el activador AFTER DELETE, que probará en el siguiente paso.

      Paso 7: Crear un activador “After Delete”

      Los activadores AFTER DELETE funcionan una vez que se elimina correctamente un registro. Un ejemplo de cómo puede usar un activador AFTER DELETE es una situación en la cual el nivel de descuento que recibe un cliente en particular se determina mediante el número de ventas realizadas durante un período definido. Si alguno de los registros del cliente se eliminan de la tabla sales, el nivel de descuento de este deberá reducirse.

      Otro uso del activador AFTER DELETE consiste en eliminar información relacionada de otra tabla una vez que se elimina un registro de una tabla básica. Por ejemplo, establecerá un activador con el que se elimine el registro del cliente si los registros de ventas con los customer_id relacionados se eliminan de la tabla sales. Ejecute el siguiente comando para crear su activador:

      • DELIMITER //
      • CREATE TRIGGER delete_related_info
      • AFTER DELETE
      • ON sales
      • FOR EACH ROW
      • Delete from customers where customer_id=OLD.customer_id;//
      • DELIMITER ;

      A continuación, ejecute lo siguiente para eliminar todos los registros de ventas asociados con un customer_id de 2:

      • Delete from sales where customer_id='2';

      Output

      Query OK, 1 row affected (0.00 sec)

      Ahora compruebe si hay registros para el cliente en la tabla sales:

      • Select * from customers where customer_id='2';

      Obtendrá un resultado Empty Set, ya que el activador eliminó el registro del cliente asociado con el customer_id de 2:

      Output

      Empty set (0.00 sec)

      Con esto, habrá usado cada una de las diferentes formas de activadores para realizar funciones específicas. A continuación, verá la manera de eliminar un activador de la base de datos si ya no lo necesita.

      Paso 8: Eliminar activadores

      Con un método similar al que se emplea para cualquier otro objeto de base de datos, puede eliminar los activadores usando el comando DROP. A continuación, se muestra la sintaxis para eliminar un activador:

      Drop trigger [TRIGGER NAME];
      

      Por ejemplo, para eliminar el último activador AFTER DELETE que creó, ejecute el siguiente comando:

      • Drop trigger delete_related_info;

      Output

      Query OK, 0 rows affected (0.00 sec)

      La necesidad de eliminar los activadores surge cuando desea recrear su estructura. En tal caso, puede eliminar el activador y redefinir uno nuevo con los diferentes comandos de activación.

      Conclusión

      A través de este tutorial, creó, utilizó y eliminó los diferentes tipos de activadores de una base de datos de MySQL. Usando un ejemplo de base de datos relacionada con los clientes, implementó activadores para diferentes casos de uso, como la validación de datos, la aplicación de lógica de negocios, el registro de auditorías y la aplicación de integridad referencial.

      Para obtener más información sobre el uso de su base de datos de MySQL, consulte lo siguiente:



      Source link

      Cómo implementar y administrar su DNS usando DNSControl en Debian 10


      El autor seleccionó la Electronic Frontier Foundation Inc para recibir una donación como parte del programa Write for DOnations.

      Introducción

      DNSControl es una herramienta de infraestructura como código que le permite implementar y administrar sus zonas de DNS usando principios de desarrollo de software estándar, el control de versiones, pruebas e implementaciones automatizadas. DNSControl es una creación de Stack Exchange y se escribió en Go.

      El uso de DNSControl elimina muchas de las dificultades de la administración manual de DNS, ya que los archivos de zona se almacenan en un formato programable. Esto le permite implementar zonas en varios proveedores de DNS de manera simultánea, identificar errores de sintaxis y aplicar su configuración de DNS de manera automática, lo que reduce el riesgo que representan los errores humanos. Otro uso frecuente de DNSControl tiene que ver con la migración rápida de su DNS a un proveedor diferente; por ejemplo, en caso de un ataque DDoS o una interrupción del sistema.

      A través de este tutorial, instalará y configurará DNSControl, creará una configuración de DNS básica y comenzará a implementar registros de DNS en un proveedor activo. Como parte de este tutorial, usaremos DigitalOcean como proveedor DNS de ejemplo. Si desea usar un proveedor diferente, la configuración es muy similar. Al finalizar, podrá administrar y probar su configuración de DNS en un entorno seguro y sin conexión, y luego implementarla de manera automática en la producción.

      Requisitos previos

      Para completar esta guía, necesitará lo siguiente:

      • Un servidor de Debian 10 preparado conforme a la configuración inicial para servidores con Debian 10, incluidos un usuario sudo no root y un firewall habilitado para bloquear los puertos no esenciales. your-server-ipv4-address hace referencia a la dirección IP del servidor en donde aloja su sitio web o dominio. your-server-ipv6-address hace referencia a la dirección IPv6 del servidor en donde aloja su sitio web o dominio.
      • Un nombre de dominio registrado por completo con DNS alojado por un proveedor compatible. En este tutorial, se utilizará your_domain en todo momento y DigitalOcean será el proveedor de servicio.
      • Una clave de API de DigitalOcean (Token de acceso personal) con permisos de lectura y escritura. Para crear uno, consulte Cómo crear un Token de acceso personal.

      Una vez que tenga todo esto listo, para comenzar inicie sesión en su servidor como usuario no root.

      Paso 1: Instalar DNSControl

      DNSControl está escrito en Go, por lo que comenzará este paso instalando Go en su servidor y configurando su GOPATH.

      Go está disponible en los repositorios de software predeterminados de Debian, lo que permite la instalación con las herramientas convencionales de administración de paquetes.

      También deberá instalar Git, ya que es necesario para que en Go se descargue e instale el software DNSControl desde su repositorio en GitHub.

      Comience actualizando el índice de paquetes locales de modo que se refleje cualquier cambio anterior:

      Luego, instale los paquetes golang-go y git:

      • sudo apt install golang-go git

      Una vez confirmada la instalación, apt descargará e instalará Go y Git, así como todas las dependencias necesarias de estos.

      A continuación, configurará las variables de entorno de ruta necesarias para Go. Si desea obtener más información sobre esto, puede leer el siguiente tutorial de información sobre GOPATH. Comience editando el archivo ~/.profile:

      Añada las siguientes líneas al final de su archivo:

      ~/.profile

      ...
      export GOPATH="$HOME/go"
      export PATH="$PATH:$GOPATH/bin"
      

      Una vez que añada estas líneas al final del archivo, guárdelo y ciérrelo. Luego vuelva a cargar su perfil cerrando y volviendo a abrir la sesión, o bien volviendo a obtener el archivo:

      Ahora que instaló y configuró Go, puede instalar DNSControl.

      El comando go get se puede usar para obtener una copia del código, compilarlo automáticamente e instalarlo en su directorio de Go:

      • go get github.com/StackExchange/dnscontrol

      Una vez completado esto, puede verificar la versión instalada para asegurar que todo funcione:

      El resultado debe tener un aspecto similar al siguiente:

      Output

      dnscontrol 2.9-dev

      Si ve un error dnscontrol: command not found, verifique bien la configuración de su ruta de Go.

      Ahora que instaló DNSControl, puede crear un directorio de configuración y conectar DNSControl a su proveedor DNS para permitir que haga cambios en sus registros de DNS.

      Paso 2: Configurar DNSControl

      En este paso, creará los directorios de configuración necesarios para DNSControl y lo conectará a su proveedor DNS para que pueda comenzar a realizar cambios en tiempo real en sus registros de DNS.

      Primero, cree un directorio nuevo en el que pueda almacenar su configuración de DNSControl y luego posiciónese en este:

      • mkdir ~/dnscontrol
      • cd ~/dnscontrol

      Nota: En este tutorial, nos enfocaremos en la configuración inicial de DNSControl. Sin embargo, para el uso en producción se le recomienda almacenar su configuración de DNSControl en un sistema de control de versiones (VCS) como Git. Entre las ventajas de esto se incluyen un control de versiones completo, la integración con CI/CD para pruebas y las implementaciones de versiones anteriores sin problemas.

      Si planea usar DNSControl para escribir archivos de zona BIND, también deberá crear el directorio zones:

      Los archivos de zona BIND son una alternativa básica estándar para almacenar zonas y registros de DNS en formato de texto simple. Originalmente se utilizaron para el software del servidor DNS BIND, pero ahora se han adoptado ampliamente como el método estándar para almacenar zonas de DNS. Los archivos de zona BIND producidos por DNSControl son útiles si quiere importarlos a un servidor DNS personalizado o con alojamiento propio, o bien para fines de auditoría.

      Sin embargo, si solo quiere usar DNSControl para aplicar cambios de DNS a un proveedor administrado, no se necesitará el directorio zones.

      A continuación, deberá configurar el archivo creds.json, lo cual permitirá la autenticación de DNSControl en su proveedor DNS y la aplicación de cambios. El formato de creds.json varia ligeramente dependiendo del proveedor DNS que utilice. Consulte la lista de proveedores de servicio en la documentación oficial de DNSControl para hallar la configuración de su propio proveedor.

      Cree el archivo creds.json en el directorio ~/dnscontrol:

      • cd ~/dnscontrol
      • nano creds.json

      Añada la configuración de muestra creds.json para su proveedor DNS al archivo. Si utiliza DigitalOcean como su proveedor DNS, puede recurrir a lo siguiente:

      ~/dnscontrol/creds.json

      {
      "digitalocean": {
        "token": "your-digitalocean-oauth-token"
      }
      }
      

      En este archivo se indican a DNSControl los proveedores de DNS con los que desea establecer conexión.

      Deberá proporcionar alguna forma de autenticación para proveedor DNS. Normalmente, se utiliza una clave de API o un token de OAuth, pero algunos proveedores requieren información adicional, como se detalla en la lista de proveedores de servicio de la documentación oficial de DNSControl.

      Advertencia: Este token brindará acceso a la cuenta de su proveedor DNS, por lo que debe protegerlo como si se tratara de una contraseña. También compruebe que, si utiliza un sistema de control de versiones, el archivo que contenga el token esté excluido (por ejemplo, con .gitignore), o cifrado de forma segura de alguna manera.

      Si utiliza DigitalOcean como su proveedor DNS, puede usar el token de OAuth requerido en la configuración de su cuenta de DigitalOcean que generó como parte de los requisitos previos.

      Si tiene varios proveedores de DNS diferentes, por ejemplo, para diferentes nombres de dominio o zonas de DNS delegadas, puede definir todos estos en el mismo archivo creds.json.

      Con esto, estableció los directorios de configuración inicial de DNSControl y configuró creds.json para permitir que DNSControl se autentique en su proveedor DNS y realice cambios. A continuación, creará la configuración para sus zonas de DNS.

      Paso 3: Crear un archivo de configuración de DNS

      Durante este paso, creará un archivo de configuración de DNS inicial, que contendrá los registros de DNS para su nombre de dominio o zona de DNS delegada.

      dnsconfig.js es el archivo de configuración de DNS principal para DNSControl. En este archivo, las zonas de DNS y sus registros correspondientes se definen usando sintaxis de JavaScript. Esto se conoce como DS o lenguaje específico de dominio. En la página de DSL en JavaScript de la documentación oficial de DNSControl hay más información disponible.

      Para comenzar, cree el archivo de configuración de DNS en el directorio ~/dnscontrol:

      • cd ~/dnscontrol
      • nano dnsconfig.js

      Luego, añada la siguiente configuración de ejemplo al archivo:

      ~/dnscontrol/dnsconfig.js

      // Providers:
      
      var REG_NONE = NewRegistrar('none', 'NONE');
      var DNS_DIGITALOCEAN = NewDnsProvider('digitalocean', 'DIGITALOCEAN');
      
      // Domains:
      
      D('your_domain', REG_NONE, DnsProvider(DNS_DIGITALOCEAN),
        A('@', 'your-server-ipv4-address')
      );
      

      Mediante este archivo de ejemplo se define un nombre de dominio o una zona de DNS en un proveedor determinado, que en este caso es your_domain alojado en DigitalOcean. También se define un ejemplo de registro A para la zona root (@) con orientación hacia la dirección IPv4 del servidor en el que aloja su dominio y sitio web.

      Existen tres funciones principales que conforman un archivo básico de configuración de DNSControl

      • NewRegistrar(name, type, metadata): define el registrador de dominio para su nombre de dominio. DNSControl puede utilizar esto para realizar los cambios necesarios, como la modificación de los servidores de nombres autoritativos. Si solo quiere usar DNSControl para administrar sus zonas de DNS, generalmente puede dejar el valor NONE.

      • NewDnsProvider(name, type, metadata): define un proveedor de servicio de DNS para su nombre de dominio o zona delegada. Aquí es donde DNSControl aplicará los cambios de DNS que realice.

      • D(name, registrar, modifiers): define un nombre de dominio o una zona de DNS delegada para DNSControl se encargue de la administración, como también los registros de DNS presentes en la zona.

      Deberá configurar NewRegistrar(), NewDnsProvider() y D() respectivamente usando la lista de proveedores de servicio de la documentación oficial de DNSControl.

      Si utiliza DigitalOcean como su proveedor DNS y solo necesita poder realizar cambios en el DNS (en lugar de servidores de nombres autoritativos también), el ejemplo del bloque de código anterior ya es válido.

      Una vez que termine, guarde y cierre el archivo.

      En este paso, creó un archivo de configuración de DNS para DNSControl, con los proveedores correspondientes definidos. A continuación, completará el archivo con algunos registros de DNS útiles.

      Paso 4: Completar su archivo de configuración de DNS

      A continuación, podrá completar el archivo de configuración de DNS con registros de DNS útiles para su sitio web o servicio, con la sintaxis de DNSControl.

      A diferencia de los archivos de zona BIND tradicionales, en los cuales los registros DNS están escritos en un formato básico, línea por línea, los registros DNS dentro de DNSControl se definen como un parámetro de función (modificador de dominio) en la función D(), como se muestra en forma resumida en el paso 3.

      Existe un modificador de dominio para cada uno de los tipos de registro de DNS estándares, entre los que se incluyen A, AAAA, MX, TXT, NS y CAA. Se encuentra disponible una lista completa de los tipos de registro en la sección Modificadores de dominios de la documentación de DNSControl.

      También se encuentran disponibles los modificadores para los registros individuales (modificadores de registros). Actualmente, se utilizan principalmente para configurar el TTL (período de vida) de registros individuales. Se encuentra disponible una lista completa de los modificadores de registros en la sección Modificadores de registros de la documentación de DNSControl. Los modificadores de registros son opcionales y en la mayoría de los casos de uso básicos pueden quedar excluidos.

      La sintaxis para configurar registros DNS varía ligeramente según cada tipo de registro. A continuación, se muestran algunos ejemplos para los tipos de registro más comunes:

      • Registros A:

        • Propósito: apuntar a una dirección IPv4.
        • Sintaxis: A('name', 'address', optional record modifiers).
        • Ejemplo: A('@', 'your-server-ipv4-address', TTL(30)).
      • Registros AAAA:

        • Propósito: apuntar a una dirección IPv6.
        • Sintaxis: AAAA('name', 'address', optional record modifiers).
        • Ejemplo: AAAA('@', 'your-server-ipv6-address') (se omitió el modificador de registros, por lo que se utilizará el TTL predeterminado).
      • Registros CNAME:

        • Propósito: convertir su dominio o subdominio en un alias de otro.
        • Sintaxis: CNAME('name', 'target', optional record modifiers).
        • Ejemplo: CNAME('subdomain1', 'example.org.') (tenga en cuenta que se debe incluir un . al final si hay algún punto en el valor).
      • Registros MX:

        • Propósito: dirigir el correo electrónico hacía direcciones o servidores específicos.
        • Sintaxis: MX('name', 'priority', 'target', optional record modifiers).
        • Ejemplo: MX('@', 10, 'mail.example.net') (tenga en cuenta que se debe incluir un . “al final si hay algún punto en el valor).
      • Registros de TXT:

        • Propósito: agregar texto simple arbitrario, a menudo utilizado para las configuraciones sin su propio tipo de registro dedicado.
        • Sintaxis: TXT('name', 'content', optional record modifiers).
        • Ejemplo: TXT('@', 'This is a TXT record.').
      • Registros CAA:

        • Propósito: restringir las entidades de certificación (CA) que pueden emitir certificados TLS para su dominio y subdominios, y presentar informes sobre ellas.
        • Sintaxis: CAA('name', 'tag', 'value', optional record modifiers).
        • Ejemplo: CAA('@', 'issue', 'letsencrypt.org').

      Con el fin de comenzar a añadir registros de DNS para su dominio o zona de DNS delegada, edite su archivo de configuración DNS:

      A continuación, puede comenzar a completar los parámetros para la función D() existente usando la sintaxis descrita en la lista anterior, así como la sección Modificadores de dominio de la documentación oficial de DNSControl. Se debe utilizar una coma (,) entre cada registro.

      A modo de referencia, el bloque de código aquí contiene una configuración de ejemplo completa para una configuración básica e inicial de un DNS:

      ~/dnscontrol/dnsconfig.js

      ...
      
      D('your_domain', REG_NONE, DnsProvider(DNS_DIGITALOCEAN),
        A('@', 'your-server-ipv4-address'),
        A('www', 'your-server-ipv4-address'),
        A('mail', 'your-server-ipv4-address'),
        AAAA('@', 'your-server-ipv6-address'),
        AAAA('www', 'your-server-ipv6-address'),
        AAAA('mail', 'your-server-ipv6-address'),
        MX('@', 10, 'mail.your_domain.'),
        TXT('@', 'v=spf1 -all'),
        TXT('_dmarc', 'v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;')
      );
      

      Una vez que haya completado su configuración inicial de DNS, guarde y cierre el archivo.

      Durante este paso, creó el archivo de configuración de DNS inicial que contiene sus registros de DNS. A continuación, probará la configuración y la implementará.

      Paso 5: Probar e implementar su configuración de DNS

      En este paso, ejecutará una verificación de sintaxis local en su configuración de DNS y luego implementará los cambios en el servidor y proveedor DNS activos.

      Primero, posiciónese en el directorio dnscontrol:

      Luego, utilice la función preview de DNSControl para verificar la sintaxis de su archivo y mostrar los cambios que se realizarán (sin efectuarlos realmente):

      Si la sintaxis de su archivo de configuración de DNS es correcta, en DNSControl se mostrará un resumen de los cambios que se realizarán. Esto debe tener un aspecto similar a lo siguiente:

      Output

      ******************** Domain: your_domain ----- Getting nameservers from: digitalocean ----- DNS Provider: digitalocean...8 corrections #1: CREATE A your_domain your-server-ipv4-address ttl=300 #2: CREATE A www.your_domain your-server-ipv4-address ttl=300 #3: CREATE A mail.your_domain your-server-ipv4-address ttl=300 #4: CREATE AAAA your_domain your-server-ipv6-address ttl=300 #5: CREATE TXT _dmarc.your_domain "v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;" ttl=300 #6: CREATE AAAA www.your_domain your-server-ipv6-address ttl=300 #7: CREATE AAAA mail.your_domain your-server-ipv6-address ttl=300 #8: CREATE MX your_domain 10 mail.your_domain. ttl=300 ----- Registrar: none...0 corrections Done. 8 corrections.

      Si ve una advertencia de error en el resultado, DNSControl proporcionará detalles sobre el tipo de error y el punto en el que se encuentra dentro de su archivo.

      Advertencia: A través del siguiente comando se harán cambios en tiempo real en sus registros DNS y posiblemente en otras configuraciones. Asegúrese de estar preparado para esto; incluya una copia de seguridad de su configuración de DNS existente y verifique que disponga de los medios necesarios para revertir los cambios si es necesario.

      Por último, puede aplicar los cambios a su proveedor DNS activo:

      Verá un resultado similar al siguiente:

      Output

      ******************** Domain: your_domain ----- Getting nameservers from: digitalocean ----- DNS Provider: digitalocean...8 corrections #1: CREATE TXT _dmarc.your_domain "v=DMARC1; p=reject; rua=mailto:abuse@your_domain; aspf=s; adkim=s;" ttl=300 SUCCESS! #2: CREATE A your_domain your-server-ipv4-address ttl=300 SUCCESS! #3: CREATE AAAA your_domain your-server-ipv6-address ttl=300 SUCCESS! #4: CREATE AAAA www.your_domain your-server-ipv6-address ttl=300 SUCCESS! #5: CREATE AAAA mail.your_domain your-server-ipv6-address ttl=300 SUCCESS! #6: CREATE A www.your_domain your-server-ipv4-address ttl=300 SUCCESS! #7: CREATE A mail.your_domain your-server-ipv4-address ttl=300 SUCCESS! #8: CREATE MX your_domain 10 mail.your_domain. ttl=300 SUCCESS! ----- Registrar: none...0 corrections Done. 8 corrections.

      Ahora, si revisa las configuraciones de DNS para su dominio en el panel de control de DigitalOcean, podrá visualizar los cambios.

      Captura de pantalla del panel de control de DigitalOcean; se muestran algunos de los cambios de DNS realizados en DNSControl.

      También puede verificar la creación de registros ejecutando una solicitud de DNS para su dominio o zona delegando usando dig.

      Si no instaló dig, deberá instalar el paquete dnsutils:

      • sudo apt install dnsutils

      Una vez que instale dig, podrá utilizarlo con el propósito de realizar una búsqueda de DNS para su dominio. Verá que los registros se actualizaron de forma correspondiente:

      Verá un resultado que muestra la dirección IP y los registros de DNS pertinentes de su zona implementada usando DNSControl. Los registros DNS pueden tardar tiempo en propagarse, por lo cual es posible que necesite esperar y ejecutar este comando de nuevo.

      En este último paso, realizó una verificación de sintaxis local del archivo de configuración de DNS, luego lo implementó en su proveedor DNS activo y verificó mediante pruebas que los cambios se realizaran correctamente.

      Conclusión

      A lo largo de este artículo, configuró DNSControl e implementó una configuración de DNS en un proveedor activo. Ahora podrá administrar y probar sus cambios de configuración de DNS en un entorno seguro y sin conexión antes de implementarlos en la producción.

      Si desea profundizar en este tema, DNSControl está diseñado para integrarse en su proceso de CI/CD, lo que le permite realizar pruebas exhaustivas y tener más control sobre su implementación en la producción. También podría considerar la integración de DNSControl en sus procesos de compilación e implementación de infraestructuras, lo que le permitirá implementar servidores y agregarlos al DNS de manera completamente automática.

      Si desea dar un paso más con DNSControl, en los siguientes artículos de DigitalOcean se ofrecen algunos pasos interesantes que puede seguir para contribuir a la integración de DNSControl en sus flujos de trabajo de administración de cambios e implementación de infraestructura:



      Source link