12 Días de DigitalOcean (Día 4) – Despliegue de Notificaciones de Cumpleaños con las Funciones de DigitalOcean

¡Bienvenido al Día 4 de 12 Días de DigitalOcean! Ayer, agregamos notificaciones SMS de Twilio a nuestro Servicio de Recordatorio de Cumpleaños, haciéndolo capaz de enviar mensajes de texto para los cumpleaños de hoy. 🎂

Hoy, llevaremos las cosas al siguiente nivel desplegando nuestro script en DigitalOcean Functions. Esto permite que nuestro servicio se ejecute en la nube sin la necesidad de un servidor dedicado, haciendo que nuestra aplicación sea ligera, escalable y lista para la automatización.

Con esta configuración, recibirás recordatorios de cumpleaños incluso cuando tu computadora esté apagada o no esté conectada a internet; ya no es necesario ejecutar el script manualmente en tu máquina. 🎉

✨ ¿Por qué DigitalOcean Functions?

A veces, todo lo que necesitas es un script simple que se ejecute ocasionalmente. Administrar la infraestructura para algo así puede ser excesivo. Ahí es donde entran Funciones. Es una plataforma sin servidor, lo que significa que puedes implementar código que se ejecuta solo cuando es necesario, y solo pagas por lo que usas. Perfecto para nuestro caso de uso: verificar cumpleaños y enviar recordatorios diariamente.

🚀 Lo que Aprenderás

Al final de hoy, sabrás cómo:

1. Configurar la herramienta doctl CLI de DigitalOcean.
2. Crear y conectarte a un espacio de nombres sin servidor (la forma de DigitalOcean de mantener organizadas las funciones).
3. Empaquetar e implementar tu Servicio de Recordatorio de Cumpleaños en Funciones de DigitalOcean.
4. Probar tu función implementada en la nube.

🛠 Lo que Necesitarás

Antes de comenzar, asegúrate de tener:

• Una cuenta de DigitalOcean.
• Un archivo .env con tus credenciales de base de datos PostgreSQL y credenciales de Twilio
  • Ver Día 1: Configurando una base de datos PostgreSQL para recordatorios de cumpleaños
  • Ver Día 3: Verificando cumpleaños y enviando notificaciones SMS

🧑‍🍳 Receta para el Día 4: Desplegando en DigitalOcean Functions

Paso 1: Configurar la CLI doctl

Si ya has configurado doctl en tu máquina, puedes omitir este paso. Para aquellos que necesitan configurarlo, sigue estas instrucciones:

Antes de empezar, hablemos brevemente sobre doctl. Es la herramienta de interfaz de línea de comandos oficial de DigitalOcean que te permite gestionar tus recursos en la nube directamente desde tu terminal. La utilizaremos para crear un espacio de nombres (una carpeta para nuestras funciones serverless), desplegar nuestro script de Python y probar la función.

Configurarlo es sencillo:

1. Instala doctl: Sigue la guía de instalación para tu sistema operativo.

2. Autentica doctl: Conéctalo a tu cuenta de DigitalOcean ejecutando:

   doctl auth init
   

3. Verifica la instalación: Asegúrate de que todo funcione correctamente ejecutando:

   doctl account get
   

Si tienes éxito, este comando devolverá detalles sobre tu cuenta de DigitalOcean, como tu correo electrónico y ID de cuenta.

Paso 2: Instalar el software Serverless

Las Funciones de DigitalOcean requieren soporte de software serverless, que necesitarás instalar. Esto es una configuración única, por lo que una vez instalado, no necesitarás hacerlo nuevamente para proyectos futuros.

Ejecuta el siguiente comando:

doctl serverless install

Puedes verificar el estado de la instalación con:

doctl serverless status

Si ves un error como:

Error: serverless support is installed but not connected to a functions namespace

No te preocupes, eso solo significa que aún no hemos creado o conectado a un espacio de nombres. Nos encargaremos de eso en el siguiente paso.

Paso 3: Crear y Conectar a un Espacio de Nombres

Los espacios de nombres son como carpetas para organizar funciones sin servidor. Vamos a crear uno para nuestro Servicio de Recordatorio de Cumpleaños:

1. Crea un nuevo espacio de nombres:

   doctl serverless namespaces create --label "mi-espacio-de-nombres-de-recordatorio-de-cumpleaños" --region "nyc1"
   

   

2. Conéctate al espacio de nombres:

   doctl serverless connect mi-recordatorio-de-cumpleaños-namespace
   

   

3. Verifica la conexión:

   doctl serverless status
   

Ahora deberías ver una confirmación de que estás conectado al espacio de nombres.

doctl serverless namespaces list

Paso 4: Inicializa y Configura la Estructura del Proyecto

DigitalOcean Functions espera una estructura de proyecto específica para implementaciones sin servidor. Puedes iniciar esta estructura usando doctl serverless init, crearla manualmente, o incluso clonar un repositorio de inicio. Para mantener las cosas simples, lo configuraremos usando doctl serverless init:

1. Ejecuta el siguiente comando para inicializar el proyecto:

   doctl serverless init --language python birthday-reminder-service
   

   

   Esto crea un directorio de proyecto local llamado my-birthday-reminder-service con la siguiente estructura predeterminada:

   my-birthday-reminder-service/
   ├── packages
   │   └── sample
   │       └── hello
   │           └── hello.py
   └── project.yml
   

   

2. Navegar al directorio del proyecto:

   cd my-birthday-reminder-service
   

3. Renombrar las carpetas para que coincidan con nuestro caso de uso:

   mv packages/sample packages/reminders
   mv packages/reminders/hello packages/reminders/birthdays
   mv packages/reminders/birthdays/hello.py packages/reminders/birthdays/__main__.py
   

4. Crea los archivos necesarios:

   • Crea un archivo .env vacío en la raíz del proyecto:

   touch .env
   

   Este archivo contendrá tus credenciales de base de datos y Twilio. El archivo estará ubicado en la raíz de la carpeta my-birthday-reminder-service.

   • Crea un archivo requirements.txt en la carpeta birthdays:

   touch packages/reminders/birthdays/requirements.txt
   

   Este archivo enumerará las dependencias de Python necesarias para tu función. Estará ubicado bajo packages/reminders/birthdays.

   • Crea un archivo build.sh en la carpeta birthdays:

   touch packages/reminders/birthdays/build.sh
   chmod +x packages/reminders/birthdays/build.sh
   

   El script build.sh es necesario para desplegar funciones con dependencias externas. El comando chmod asegura que el script sea ejecutable en sistemas Mac/Linux.

Estructura Actualizada: Después de completar estos pasos, la estructura de tu proyecto debería verse así:

my-birthday-reminder-service/
├── project.yml
├── .env
├── packages
│   └── reminders
│       └── birthdays
│           ├── __main__.py
│           ├── requirements.txt
│           ├── build.sh
├── .gitignore

Paso 5: Actualiza Archivos

Ahora que la estructura está en su lugar, vamos a poblarla con los archivos necesarios. Abre el directorio my-birthday-reminder-service en tu editor de código favorito.

1. Actualizar project.yml

El archivo project.yml es un archivo de configuración que define la estructura de su proyecto sin servidor, las variables de entorno y las funciones. Reemplace su contenido con:

packages:
  - name: reminders
    shared: false
    environment:
      DO_DB_NAME: "${DB_NAME}"
      DO_DB_USER: "${DB_USER}"
      DO_DB_PASSWORD: "${DB_PASSWORD}"
      DO_DB_HOST: "${DB_HOST}"
      DO_DB_PORT: "${DB_PORT}"
      TWILIO_ACCOUNT_SID: "${TWILIO_ACCOUNT_SID}"
      TWILIO_AUTH_TOKEN: "${TWILIO_AUTH_TOKEN}"
      TWILIO_PHONE_FROM: "${TWILIO_PHONE_FROM}"
      TWILIO_PHONE_TO: "${TWILIO_PHONE_TO}"
    functions:
      - name: birthdays
        runtime: python:default

Este archivo configura el paquete de recordatorios y mapea las variables de entorno a las Funciones de DigitalOcean. Cada variable corresponde a las credenciales necesarias para su base de datos y la integración con Twilio.

2. Actualizar su archivo .env

Consulte Día 1: Configuración de una base de datos PostgreSQL para recordatorios de cumpleaños para las credenciales de la base de datos y Día 3: Comprobación de cumpleaños y envío de notificaciones SMS para las credenciales de Twilio para completar los siguientes valores:

# Credenciales de la base de datos (del Día 1)
DB_HOST=<your-database-hostname>
DB_NAME=<your-database-name>
DB_USER=<your-database-username>
DB_PASSWORD=<your-database-password>
DB_PORT=5432  # Puerto predeterminado de PostgreSQL

# Credenciales de Twilio (del Día 3)
TWILIO_ACCOUNT_SID=<your-twilio-account-sid>
TWILIO_AUTH_TOKEN=<your-twilio-auth-token>
TWILIO_PHONE_FROM=<your-twilio-phone-number>
TWILIO_PHONE_TO=<your-personal-phone-number>

3. Agregar Dependencias

Actualiza el archivo requirements.txt con las siguientes dependencias:

pg8000  
python-dotenv  
twilio  

4. Actualizar build.sh

Agrega el siguiente script al archivo build.sh:

#!/bin/bash
set -e

# Imprimir el directorio de trabajo actual para depuración
echo "Current working directory: $(pwd)"

# Verificar si requirements.txt existe
if [[ -f "requirements.txt" ]]; then
  echo "Found requirements.txt in $(pwd)"
else
  echo "Error: requirements.txt not found in $(pwd)"
  exit 1
fi

# Crear un entorno virtual
virtualenv --without-pip virtualenv

# Instalar dependencias desde requirements.txt
pip install -r requirements.txt --target virtualenv/lib/python3.9/site-packages

Este script asegura que todas las dependencias estén empaquetadas correctamente con tu función. El comando chmod +x del Paso 4 asegura que sea ejecutable.

5. Actualizar __main__.py

Este es el script principal para tu Servicio de Recordatorio de Cumpleaños. Esencialmente estamos utilizando el script que construimos en el Día 3 para enviar notificaciones de cumpleaños. Sin embargo, para hacerlo compatible con las Funciones de DigitalOcean, necesitamos hacer algunos pequeños ajustes.

Actualiza el archivo __main__.py con el siguiente contenido:

# servicio_recordatorio_cumpleaños/__main__.py

from datetime import datetime
import pg8000
from dotenv import load_dotenv
from twilio.rest import Client
import os

# Cargar variables de entorno
load_dotenv()

def main(params):
    """DigitalOcean Functions entry point."""
    try:
        # Conectar a la base de datos
        connection = pg8000.connect(
            host=os.getenv("DO_DB_HOST"),
            database=os.getenv("DO_DB_NAME"),
            user=os.getenv("DO_DB_USER"),
            password=os.getenv("DO_DB_PASSWORD"),
            port=int(os.getenv("DO_DB_PORT"))
        )
        cursor = connection.cursor()

        # Obtener el mes y el día de hoy
        today = datetime.now()
        today_month = today.month
        today_day = today.day

        # Consulta para obtener contactos cuyo cumpleaños coincide con la fecha de hoy
        cursor.execute(
            """
            SELECT first_name, last_name, birthday
            FROM contacts
            WHERE EXTRACT(MONTH FROM birthday) = %s
              AND EXTRACT(DAY FROM birthday) = %s;
            """,
            (today_month, today_day)
        )
        rows = cursor.fetchall()

        # Notificar por cada contacto que coincida
        if rows:
            account_sid = os.getenv("TWILIO_ACCOUNT_SID")
            auth_token = os.getenv("TWILIO_AUTH_TOKEN")
            client = Client(account_sid, auth_token)

            for row in rows:
                first_name, last_name, _ = row
                message = client.messages.create(
                    body=f"🎉 It's {first_name} {last_name or ''}'s birthday today! 🎂",
                    from_=os.getenv("TWILIO_PHONE_FROM"),
                    to=os.getenv("TWILIO_PHONE_TO")
                )
                print(f"Message sent for {first_name} {last_name}. Message SID: {message.sid}")
        else:
            print("No birthdays today.")

        # Cerrar el cursor y la conexión
        cursor.close()
        connection.close()

    except Exception as e:
        print(f"An error occurred: {e}")

Aquí están los cambios que hemos realizado:

1. Se agregó una función main(params): DigitalOcean Functions espera una función de punto de entrada llamada main, que toma un argumento params. Aquí es donde comienza la ejecución de la función.

2. Se movió la lógica del script dentro de la función main:
   El código del Día 3 se ha envuelto dentro de la función main para cumplir con este requisito.

3. Todo lo demás permanece igual:
   La lógica de conexión a la base de datos, las verificaciones de cumpleaños y la lógica de notificación por SMS no han cambiado.

Paso 5: Empaquetar y Desplegar

Con todo en su lugar, despliega tu proyecto en DigitalOcean Functions:

1. Desplegar el proyecto:

doctl serverless deploy my-birthday-reminder-service

Para verificar que tu función se ha desplegado correctamente en el espacio de nombres:

1. Visita el Panel de Control de DigitalOcean y navega a Functions en la barra lateral izquierda.
2. Ubica tu espacio de nombres (por ejemplo, my-birthday-reminder-namespace).
3. Verifica que tu función aparezca bajo el espacio de nombres, típicamente listada como reminders/birthdays.
4. Haz clic en el nombre de la función para ver detalles, incluyendo registros, configuración e historial de invocaciones.

Paso 6: Prueba tu Función Desplegada

Una vez que tu función esté desplegada, es hora de probarla. Puedes invocar la función manualmente para asegurarte de que funciona como se espera. Hay dos formas de hacerlo:

Opción 1: Usando la CLI de DigitalOcean

doctl serverless functions invoke reminders/birthdays

Si todo está configurado correctamente, tu función se ejecutará en la nube, verificando los cumpleaños de hoy y enviando notificaciones por SMS.

![https://doimages.nyc3.cdn.digitaloceanspaces.com/006Community/12-Days-of-DO/Postgressql-birthday/birthday_reminder_service_text_message.jpeg]

Opción 2: Usando el Panel de Control de DigitalOcean

1. Ve al Panel de Control de DigitalOcean.
2. Navega a Funciones y localiza tu función de recordatorios/cumpleaños.
3. Haz clic en Ejecutar para ejecutarla manualmente.
4. Visualiza la salida y los registros directamente en la consola.

Este método es especialmente útil si prefieres una interfaz visual o quieres verificar los registros en un formato limpio y fácil de leer.

Consejos de Pruebas

Cuando invoques la función, comprobará si hay cumpleaños que coincidan con la fecha de hoy. Si hay una coincidencia, recibirás un mensaje de texto con los detalles. Para probar la función de manera efectiva:

• Agrega uno o más cumpleaños en tu base de datos que coincidan con la fecha actual.
• Verifica la consola o los registros de CLI para confirmar que la función se ejecutó correctamente.

🎁 Resumen

Aquí está lo que logramos hoy:

✅ Configuramos doctl y creamos un espacio de nombres para nuestro proyecto.
✅ Refactorizamos el script de Python para su implementación.
✅ Empaquetamos e implementamos el Servicio de Recordatorio de Cumpleaños en DigitalOcean Functions.
✅ Probamos la función en la nube utilizando tanto la CLI como el Panel de Control de DigitalOcean.

Próximamente: Aunque este es un gran paso adelante, todavía estamos ejecutando la función manualmente. En la próxima publicación, automatizaremos este proceso para que el Servicio de Recordatorio de Cumpleaños se ejecute automáticamente todos los días a una hora específica. Imagina despertarte con un recordatorio por mensaje de texto sin mover un dedo—¡hagamos que eso suceda mañana! 🚀