El objeto de esta lección es presentar la suite de automatización Akromio en la que apoyarnos para crear sitios webs con Jekyll más fácilmente.

Al finalizar, sabrá:

  • Cómo crear estructuras de directorios iniciales de un sitio Jekyll con Gattuso.

  • Cómo crear archivos específicos de un sitio Jekyll con Gattuso.

  • Cómo crear un flujo de trabajo para la publicación de un sitio en GitHub Pages con Gattuso.

  • Cómo obtener la línea de comandos con la que ejecutar Jekyll en Docker.

  • Cómo obtener lo que hacer para publicar un servicio en la red Tor.

Introducción

Akromio, https://akromio.com, es una suite de automatización para IT. Contiene varias aplicaciones con las que ejecutar tareas automatizadas, por ejemplo:

  • Para construir archivos a partir de plantillas.

  • Para ejecutar ataques de denegación de servicio.

  • Para ejecutar pruebas de carga de sitios webs.

  • Para realizar aserciones en pruebas de unidad, integración o sistema.

  • Para utilizar dobles de pruebas en pruebas de unidad o de integración.

En nuestro caso, no vamos a profundizar en cada una de ellas. Nos centraremos únicamente en Gattuso y en los constructores que nos permitirán iniciar proyectos de GitHub Pages más rápidamente.

Instalación

Gattuso se ha desarrollado para Node.js, por lo que tendremos que tener esta plantaforma instalada, como mínimo su versión 18. Una vez instalada, podemos usar el siguiente comando para instalar gattuso:

$ npm i -g @akromio/gattuso

Una vez instalado, comprobaremos que tenemos acceso al comando con:

$ gattuso help

Registros y catálogos

Gattuso utiliza dos conceptos imprescindibles que debemos conocer sí o sí, los registros y los catálogos. Un registro (registry) es un almacén de catálogos. Actualmente, estos registros se pueden encontrar en un directorio local o en GitHub. Un catálogo (catalog), por su parte, es un conjunto de trabajos que podemos ejecutar.

En nuestro caso, vamos a utilizar el registro akromio/pages, https://github.com/akromio/pages-registry, y diversos catálogos contenidos en él. El registro se indica mediante la opción -g como sigue:

-g git:///pages

Observe que lleva tres barras (///). Sólo para que comprenda un poco mejor las cosas, la ubicación de un registro de GitHub sigue el siguiente formato básico:

git://usuario/repositorio

En nuestro caso, el repositorio es akromio/pages-registry. El sufijo -registry no hace falta indicarlo. Para evitar tener que especificar explícitamente el usuario, la suite permite que lo omitamos, cogiendo su valor de la variable de entorno KRM_REGISTRY_GIT_USER que, en caso de no estar definida, será akromio. Pero en este caso, tenemos que dejar la sección vacía, de ahí que tengamos que indicar, por un lado, :// para separar el protocolo y, a continuación, una tercera, dejando vacía la parte de la cuenta de usuario. Puede consultar las variables de entorno utilizadas por los registros de Git mediante el siguiente comando:

$ gattuso e REGISTRY_GIT

 Variable                 Value                      Desc.                                                                                                                
--------------------------------------------------------------------------------------------
 KRM_REGISTRY_GIT_BRANCH  master                     Branch name to use.
 KRM_REGISTRY_GIT_HOST    raw.githubusercontent.com  Host where the Git repository is.
 KRM_REGISTRY_GIT_PREFIX  registry                   Path prefix to use.
 KRM_REGISTRY_GIT_REPO    builtin-registry           Repository name to use as registry.
 KRM_REGISTRY_GIT_USER    akromio                    User name where the Git repository is.

Con el registro pages, podremos hacer cosas como:

  • Crear la estructura de directorios inicial de un sitio web Jekyll.

  • Generar un flujo de trabajo para su publicación en GitHub Pages.

  • Generar encabezamientos (front matters) de página.

  • Generar un archivo inicial Gemfile.

  • Generar un archivo de configuración _config.yaml.

  • Generar un archivo de datos en _data.

Básicamente, la idea es poder crear ciertas cosas comunes rápidamente.

Los catálogos definen trabajos, donde un trabajo (job) no es más que una operación a ejecutar. En nuestro caso, nos vamos a centrar en las macros, que describen una secuencia de operaciones a realizar una detrás de otra. Los catálogos del registro pages contienen varias macros, conocidas formalmente como creadoras (scaffolders), que realizan preguntas al usuario y, a continuación, crean uno o más archivos y/o directorios acorde a los respondido.

Generación de la estructura de un sitio web

Para generar una estructura inicial de un sitio web Jekyll, usando el tema minima, podemos utilizar

$ gattuso -g git:///pages -c minima r website

Recordemos, con la opción -g indicamos el registro donde se encuentra el catálogo. Con -c, indicamos el catálogo a utilizar. Mediante el comando run, abreviado como r, se indica el trabajo a ejecutar; en nuestro caso, website.

Para conocer los trabajos disponibles, bastará con:

$ gattuso -g git:///pages -c minima

location: git:///jobs/catalogs/minima.yaml

jobs:
 job        type   tags  desc.                                                           
-----------------------------------------------------------------------------------------
 config     macro        Create the _config.yaml file                                    
 gemfile    macro        Create the Gemfile file                                         
 gitignore  macro        Create the .gitignore file                                      
 style      macro        Create the SCSS file for overriding this default                
 website*   macro        Create the scaffold for a Jekyll website using the minima theme 

El trabajo marcado con un asterisco (*) es el predeterminado, aquel que se ejecutará si no especificamos ninguno explícitamente.

Generación del archivo Gemfile

Recordemos que el archivo Gemfile es necesario si vamos a utilizar la imagen jekyll/jekyll de Docker. Este archivo con un contenido inicial se puede crear mediante el siguiente comando que hace uso del catálogo predeterminado:

$ gattuso -g git:///pages r gemfile

Todo registro puede tener un catálogo predeterminado (default catalog), aquel que se usa si no se especifica uno explícitamente. Es el que tiene como nombre default. En el caso del registro pages, el catálogo predeterminado tiene trabajos comunes, independientes del tema que estemos usando.

Generación de un encabezamiento

Para generar un encabezamiento, utilizaremos:

$ gattuso -g git:///pages r front-matter

Solicitará información del encabezamiento y mostrará un encabezamiento que debemos copiar y pegar en el correspondiente archivo de página.

Generación de una nueva página

Para generar una página nueva con su correspondiente encabezamiento, usaremos:

$ gattuso -g git:///pages r page

Sobrescritura del estilo predeterminado del tema minima

Para generar el archivo style.scss para la sobrescritura del estilo del tema minima, use el siguiente comando:

$ gattuso -g git:///pages -c minima r style

Generación de un flujo de trabajo de GitHub Actions

Para crear un flujo de trabajo para la publicación de un sitio web pregenerado mediante GitHub Actions, podemos utilizar:

$ gattuso -g git:///pages -c actions r workflow

Obtención del comando para ejecutar Jekyll con Docker

Para conocer un comando con el que ejecutar Jekyll con Docker:

$ gattuso -g git:///pages r docker

Obtención de los comandos para ejecutar un servicio cebolla

Si lo que necesita es saber qué hacer para publicar un sitio web Jekyll en la red Tor:

$ gattuso -g git:///pages r tor