Netlify
Tags: javascript, node, netlify, asciidoctor
Published: 2021-05-30 20:19:54

---
title: Netlify
published: true
date: 2020-12-04 00:00:00 UTC
tags: javascript,node,netlify,asciidoctor
canonical_url: https://jorge.aguilera.soy/blog/2020/netlify.html
---

Netlify es una plataforma que ofrece hosting y servicios de backend para aplicaciones web y sitios "estáticos"

<dl>
<dt>INFO</dt>
<dd>
<p>Por sitios estáticos entendemos aquellas aplicaciones donde el código (si lo hay) se ejecuta
en el cliente, sin necesidad de una aplicación que genere la página tipo php, java, ruby, etc. Simplemente
se alojan páginas html, css, javascript y el navegador del cliente las descarga y muestra.</p>
</dd>
</dl>

En lo relativo a Netlify, con "servicios de backend para aplicaciones web" me refiero a que podemos desplegar en nuestro site funciones javascript y/o Go (por ahora) que se ejecutan en el backend al ser invocadas por el front, así como algunas funcionalidades tipo tratamiento de formularios enviados por el usuario, un sistema de autentificación, etc.

En esta especie de tutorial voy a contar cómo lo utilizo yo, no queriendo decir esto que sea la forma correcta (aunque a mí me funciona) ni que use todas las funcionalidades.

Así mismo, para lo que lo uso me sirve la capa gratuita por lo que no contaré nada que no esté incluida en ella. Con esta capa puedes crear tantos sites como quieras e incluso si tienes un dominio podrás asociarlo a uno de ellos

Una vez que hayas creado una cuenta con tu correo o con tu cuenta Gitlab/Github podrás ir "completando" las diferentes secciones que mostraré a continuación

 ![netlify1](https://jorge.aguilera.soy/images/2020/netlify/netlify1.png)

Figure 1. dashboard

## Hello World

El primer ejemplo es desplegar un simple "Hello World".

- crea un directorio "helloworld"

- crea un fichero `index.html`

index.html

```
<html>
  <body>
    Hello World
  </body>
</html>
```

- selecciona en el dashboard el menú "sites"

- arrastra la carpetea a la parte central de la página de Netlify (similar al de la imagen)

 ![netlify2](https://jorge.aguilera.soy/images/2020/netlify/netlify2.png)

Eso es todo. A los pocos segundos estará disponible en Internet, bajo un nombre aleatorio generado por Netlify.

 ![netlify3](https://jorge.aguilera.soy/images/2020/netlify/netlify3.png)

En la seccion de "site details" podremos cambiar el nombre por uno más adecuado, siempre que se encuentre libre. Como puedes ver lo que no puedes cambiar, por ahora, es el dominio `netlify.app`

 ![netlify4](https://jorge.aguilera.soy/images/2020/netlify/netlify4.png)

Cuando se encuentre desplegado el site (con el único index.html) podremos actualizarlo repitiendo la misma operación pero sobre el site creado.

## Hello VueJS

Podemos complicar un poco más el `hello world` y crear una aplicación VueJS (por ejemplo).

Tras instalar el CLI de Vue ejecutaremos:

`$ vue create hellowvue`

y una vez que tengamos la aplicación a nuestro gusto, generaremos la versión a distribuir

`$ npm run build`

Para desplegar el aplicativo seguiremos los mismos pasos que en el caso anterior seleccionando esta vez la carpeta`dist` que nos generó el build.

## Netlify CLI

Netlifiy proporciona un cliente de consola con el que podemos desplegar desde la la terminal nuestra aplicación sin necesidad de usar el drag&drop del explorador. Para ello necesitaremos tener instalado el `node` en nuestro sistema

`$ npm install netlify-cli -g`

y cuando se complete la instalación haremos login desde la consola

`$ netlify login`

lo cual nos abrirá un navegador para autentificarnos en Netlify

Una vez configurado y autentificado podremos usar el CLI para desplegar la aplicación desde la línea de consola bien a un site existente o a uno nuevo

`$ netlify init`

donde podremos indicarle que queremos un site nuevo, por ejemplo, o uno ya existente.

Así mismo podremos correr la aplicación VueJS anterior como si se estuviera ejecutando en Netlify desde el directorio donde hemos creado la aplicación Vue:

`$ netlify dev`

O incluso crear una URL temporal que podremos compartir para que se pueda acceder a ella desde Internet

`$ netlify dev --live`

## AWS Lambda en nuestro site

La capa gratuita nos permite desplegar también funciones javascript (o Go) que se ejecutan en el backend cloud asociado a nuestro site, de tal forma que por ejemplo el front pueda hacer peticiones GET o POST a una URL del site para que se ejecuten procesos que no se pueden correr en el cliente. Por ejemplo yo lo he usado para:

- cada vez que alguien visita una página se invoca una función backend que manda un mensaje a un canal de Telegram. Como las credenciales no pueden ser públicas, esta ejecución corre en un entorno back donde las credenciales son proporcionadas como variables de entorno

- acceder a una hoja GoogleSheet y leer o escribir en ella ante ciertos eventos. Por ejemplo renderizar un json con unas celdas determinadas que el front parsea y muestra formateado.

- un bot de Slack que reacciona ante ciertos comandos

- un bot de Telegram

- etc

| | La capa gratuita te permite tener tantas functions como quieras con un máximo de 125K invocaciones al mes (para mis cosas me sobran). OJO que no son tareas en background, para eso necesitarás la siguiente capa de pago, sino funciones con un timeout definido. |

En primer lugar configuraremos nuestro site con un fichero `netlify.toml` donde le indicaremos en qué directorio residen nuestras funciones (además de otras configuraciones como por ejemplo qué directorio queremos publicar como frontend)

netlify.toml

```
[build]
  publish = "dist"
  functions = "functions/"
```

Crearemos el directorio `functions/hellovue` y crearemos en él el fichero `hellowvue.js` siguiente:

helloowvue.js

```
exports.handler = async function(event, context) {
    return {
        statusCode: 200,
        body: JSON.stringify({message: "Hello World"})
    };
}
```

y ahora podremos desplegar desde línea de comandos tanto nuestro frontend como nuestras funciones simplemente ejecutando:

`$netlify deploy`

Una vez desplegado el site tendremos bajo el subdominio creado un URI al que podremos invocar, tal que`https:///XXXXXXXX.netlify.app/.netlify/functions/hellowvue` :

```
$ curl https://5fcca9be43cd1713632cbf4d--xxxxxxxx.netlify.app/.netlify/functions/hellowvue
{"message":"Hello World"}
```

A continuación un ejemplo más elaborado de lo que podría ser una function de Netlify. En este ejemplo en cada invocación se creará un nuevo registro en una hoja GooglSheet

```
var GoogleSpreadsheet = require('google-spreadsheet');
var async = require('async');

// spreadsheet key is the long id in the sheets URL
var doc = new GoogleSpreadsheet(process.env.GOOGLE_SHEET);
var sheet;

exports.handler = function(event, context, callback) {

  var obj = JSON.parse(event.body);
  obj.when = new Date().toISOString();

  async.series([
    function setAuth(step) {
      var creds_json = {
        client_email: process.env.GOOGLE_CLIENT_EMAIL,
        private_key: process.env.GOOGLE_PRIVATE_KEY.replace(new RegExp("\\\\n", "\g"), "\n")
      }
      doc.useServiceAccountAuth(creds_json, step);
    },
    function getInfoAndWorksheets(step) {
      doc.getInfo(function(err, info) {
        sheet = info.worksheets[0];
        step();
      });
    },
    function addRow(step) {
      sheet.addRow( obj, function( err, rows ){
        step();
      });
    }
  ], function(err){
      if( err ) {
        console.log('Error: '+err);
      }
      callback(null, {
          statusCode: 200,
          body: "OK"
      });
  });

}
```

Básicamente nos identificamos ante Google, recuperamos la primera hoja y añadimos una Row nueva con el json recibido más la fecha de ejecución.

Para que este ejemplo funcione deberemos haber creado unas variables de entorno a través de la consola de Netlify y darle los valores adecuados a

- GOOGLE\_SHEET

- GOOGLE\_CLIENT\_EMAIL

- GOOGLE\_PRIVATE\_KEY

## CI con Netlify

En lugar de desplegar desde tu local, puedes conectar tu cuenta de Github o Gitlab con Netlify y asociar proyectos alojados en ellos con sites creados en este, de tal forma que ante un commit en tu repo se ejecute un build en Netlify para publicar el site.

Así por ejemplo, siguiendo con el caso anterior, puedes crear un repo en Gitlab `hellowvue` y desde Netlify crear un site nuevo desde él seleccionando "New site from Git" desde el dashbaord:

 ![netlify1](https://jorge.aguilera.soy/images/2020/netlify/netlify1.png)

Figure 2. gitlab

Una vez seleccionado el repo que queremos asociar se ejecutará el build en el cloud de Netlify y nos lo desplegará. A partir de aquí, cada commit que realizemos en `master` (configurable) ejecutará de nuevo el pipeline y el despliegue.

## Pipeline de Gitlab

En algunas ocasiones nuestro proyecto consistirá en algo más complejo que simplemente publicar un site, como por ejemplo compilar una librería Java, publicarla en Maven y actualizar la documentación. Para estos casos yo uso el pipeline de Gitlab el cual no sólo permite separar esos pasos en `stages` sincronizados de una forma muy potente, sino que también permite publicar la docu de la misma forma que Netlify, esta vez bajo el dominio `gitlab.io`

Como Gitlab no ofrece las características de Netlify como la de functions (y otras como envío de formularios, etc) podemos delegar la publicación del site a Netlify mientras el pipeline de Gitlab sigue realizando los otros pasos (de forma resumida: Gitlab ejecuta la parte pesada y Netlify la publicación del site).

Para ello simplemente deberemos crear un `step` en nuestro pipeline de Gitlab que invoque la publicación en Netlify. Este step va a requerir de dos variables extraídas de este proveedor: el ApiToken y el AppId del repo

El ApiToken lo obtenemos desde nuestro perfil en Netlify

 ![netlify5](https://jorge.aguilera.soy/images/2020/netlify/netlify5.png)

Figure 3. ApiToken

y el AppId del propio site

 ![netlify4](https://jorge.aguilera.soy/images/2020/netlify/netlify4.png)

Figure 4. AppId

Estos dos valores los deberemos configurar en nuestro repo Gitlab. Como el ApiToken es el mismo para todos los sites de Netlify, puesto que es el personal, y lo único que cambia en cada proyecto es el AppId yo tengo puesto el ApiToken a nivel de grupo y así sólo configuro el de proyecto:

 ![gitlab1](https://jorge.aguilera.soy/images/2020/netlify/gitlab1.png)

Figure 5. gitlab

Una vez configurado, ya puedo ejecutar mi pipeline de Gitlab (bien de forma manual, en cada commit, o de forma planificada) y publicar en Netlify automáticamente. Este sería un ejemplo de pipeline en mi proyecto Gitlab:

.gitlab-ci.yml

```
stages:
  - build
  - staging
  - deploy

groovy:
  stage: build
  image:
    name: groovy:2.5.9
  script:
    - groovy dump.groovy
    - cp estaciones.json docs
  artifacts:
    paths:
      - docs

antora:
  stage: staging
  image:
    name: jagedn/antora-with-extensions
    entrypoint: [/bin/sh, -c]
  variables:
    ASCIIDOC_COPY_TO_CLIPBOARD: "true"
    DOCSEARCH_ENABLED: "true"
    DOCSEARCH_ENGINE: "lunr"
    NODE_PATH: "$$(yarn global dir)/node_modules"
  dependencies:
    - groovy
  script:
    - ls -lhat docs/modules/ROOT/pages
    - antora --generator antora-site-generator-lunr estaciones.yml
    - mv docs/estaciones.json build/main/final
  artifacts:
    paths:
      - build

netlify:
  stage: deploy
  image: node:10.15.3
  script:
    - npm i -g netlify-cli
    - netlify deploy --site $NETLIFY_SITE_ID --auth $NETLIFY_AUTH_TOKEN --prod
  dependencies:
    - antora
  only:
    - master
```

Este pipeline corresponde al proyecto "Estaciones de servicio" que de forma diaria se descarga los precios de todas las gasolineras de España, genera un site estático y lo publica en Netlify aplicando la técnica descrita ([https://gitlab.com/jorge-aguilera/estaciones-de-servicio/](https://gitlab.com/jorge-aguilera/estaciones-de-servicio/)).

<dl>
<dt>INFO</dt>
<dd>
<p>Otra cosa "chula" que puedes hacer es usar la funcionalidad de Gitlab para publicar la documentación de
tu proyecto mientras que despliegas el proyecto en sí mismo en Netlify</p>
</dd>
</dl>

Aquí puedes ver el resultado final:

[https://estaciones-de-servicio.netlify.app/](https://estaciones-de-servicio.netlify.app/)

## Blog

Por último, otra funcionalidad que he probado en Netlify es la de asociar un site con un dominio propio.

Por ejemplo este blog que estás leyendo se encuentra alojado en Netlify bajo el nombre jorge-aguilera-blog.netlify.app pero también está asociado al nombre jorge.aguilera.soy

Para ello, en primer lugar tuve que comprar el dominio `aguilera.soy` a través de un proveedor de servicios (hasta donde sé puedes usar cualquiera, Good Dady, ConfigBox, Google, Arsys, …​) y simplemente configurar en él los servidores DNS que Netlify me indicaba.

Una vez configurado (y tras una espera que puede ser de varios minutos a algunas horas) Netlify detecta que sus servidores están asociados a ese dominio y entonces ya puedes crear el subdominio que quieras en el site.

 ![netlify6](https://jorge.aguilera.soy/images/2020/netlify/netlify6.png)

Figure 6. domain

## Resumen

Aún quedan otras funcionalidades que no he investigado como probar el CMS (Content Management System, un Wordpress, vamos) , recibir un correo cuando un usuario rellena un formulario y alguna otra cosa. A modo de resumen las cosas que hago con la capa gratuita son:

- publicar un blog usando JBake con mi propio dominio

- enviar mensajes a un canal de Telegram cuando hay visitas en una página

- escribir en una hoja Google

- alojar Bots simples de Slack o Telegram

- generar sites y publicarlos de forma diaria

- divertirme