Instalar GOWA: API REST de WhatsApp con Go, Docker y SQLite

Instalación de GOWA 3.4.0 para conectar aplicaciones Python, Django o Java con WhatsApp mediante una API REST.

¿Qué vamos a instalar?
En este tutorial instalaremos GOWA, una implementación de WhatsApp Web basada en Go y whatsmeow, utilizando Docker y SQLite para almacenar los datos de las sesiones.

1. Arquitectura

La idea es utilizar GOWA como una capa intermedia entre nuestra aplicación y WhatsApp. Nuestra aplicación no necesita comunicarse directamente con el protocolo de WhatsApp.

┌──────────────────────────┐
│   Django / Python / Java │
│        Tu aplicación     │
└────────────┬─────────────┘
             │
             │ HTTP REST API
             ▼
┌──────────────────────────┐
│           GOWA           │
│        Puerto 3000       │
└────────────┬─────────────┘
             │
             │ whatsmeow
             ▼
┌──────────────────────────┐
│         WhatsApp         │
└──────────────────────────┘

Esta arquitectura permite que nuestra aplicación utilice WhatsApp mediante solicitudes HTTP y webhooks.

2. Requisitos

Para este tutorial necesitamos:

• Linux
• Docker
• Git
• Acceso a Internet
• Un número de WhatsApp para realizar la vinculación

3. Crear el directorio del proyecto

Creamos un directorio para mantener separado GOWA de otros servicios Docker.

cd /home/docker

mkdir gowa

cd gowa

4. Descargar GOWA

Clonamos el repositorio del proyecto:

git clone https://github.com/aldinokemal/go-whatsapp-web-multidevice.git .

Después podemos comprobar la estructura:

ls -la

La estructura principal del proyecto contiene, entre otros elementos:

gowa/
├── docker/
│ ├── entrypoint.sh
│ └── golang.Dockerfile
├── docs/
├── gallery/
├── src/
│ ├── cmd/
│ ├── config/
│ ├── domains/
│ ├── infrastructure/
│ ├── statics/
│ ├── ui/
│ ├── .env.example
│ ├── go.mod
│ └── main.go
├── docker-compose.yml
├── Dockerfile
└── readme.md

5. Crear el archivo de configuración

El proyecto proporciona un archivo de ejemplo llamado src/.env.example.

Lo copiamos para crear nuestra configuración:

cp src/.env.example src/.env

6. Configurar SQLite

Para esta instalación decidimos utilizar SQLite porque no necesitamos instalar un servidor de base de datos adicional.

En el archivo:

src/.env

configuramos:

DB_URI=file:storages/whatsapp.db?_foreign_keys=on

Ventaja de SQLite:
Para una instalación individual o de pruebas es muy práctico porque toda la base de datos se almacena en un archivo.

7. Configurar el puerto

GOWA utiliza el puerto 3000 en esta instalación:

APP_PORT=3000
APP_HOST=0.0.0.0

8. Configurar autenticación

También podemos proteger la API mediante autenticación básica.

En src/.env utilizamos:

APP_BASIC_AUTH=user1:pass1,user2:pass2

En este ejemplo podremos utilizar:

Usuario	Contraseña
user1	pass1
user2	pass2

Importante:
Estos valores son solamente para el ejemplo. En una instalación real debemos utilizar credenciales diferentes y seguras.

9. Configurar los directorios persistentes

Creamos los directorios que utilizaremos para conservar los datos aunque eliminemos o recreemos el contenedor.

mkdir -p storages
mkdir -p statics

La estructura queda aproximadamente así:

gowa/
├── storages/
│ └── Datos persistentes y SQLite
├── statics/
│ └── Archivos estáticos
├── src/
│ └── .env
└── docker/

10. Construir la imagen Docker

En lugar de utilizar Docker Compose, en este tutorial vamos a construir y ejecutar el contenedor manualmente.

docker build \
  -t gowa:local \
  -f docker/golang.Dockerfile .

Docker construirá la imagen utilizando el Dockerfile incluido en el proyecto.

11. Ejecutar GOWA manualmente

Una vez construida la imagen podemos crear el contenedor:

docker run -d \
  --name gowa \
  -p 3000:3000 \
  --env-file src/.env \
  -v /home/docker/gowa/storages:/app/storages \
  -v /home/docker/gowa/statics:/app/statics \
  gowa:local

Aquí tenemos varios parámetros importantes:

Parámetro	Función
-d	Ejecuta el contenedor en segundo plano.
--name gowa	Asigna el nombre GOWA al contenedor.
-p 3000:3000	Expone el puerto 3000.
--env-file src/.env	Carga las variables de configuración.
-v .../storages:/app/storages	Persiste la base de datos y los datos de WhatsApp.
-v .../statics:/app/statics	Persiste archivos estáticos.

12. Comprobar el contenedor

Podemos comprobar que el contenedor está ejecutándose:

docker ps

También podemos utilizar:

docker ps --format "table {{.Names}}\t{{.Image}}\t{{.Status}}"

13. Revisar los logs

Para comprobar que GOWA inició correctamente:

docker logs -f gowa

En nuestra instalación obtuvimos:

INFO Server started on:     http://[::]:3000
INFO Total handlers:        127
INFO Prefork:               Disabled
INFO PID:                   1

Instalación correcta.
El mensaje Server started on: http://[::]:3000 indica que el servidor HTTP de GOWA está funcionando correctamente.

14. Probar la API

Si hacemos una petición sin autenticación:

curl http://localhost:3000

obtenemos:

Unauthorized

Esto es correcto porque configuramos autenticación básica.

15. Probar con usuario y contraseña

Utilizamos la opción -u de curl:

curl -u user1:pass1 http://localhost:3000

En este caso GOWA devuelve la página HTML de la aplicación.

Resultado:
La respuesta HTML confirma que GOWA está funcionando y que la autenticación está siendo aplicada correctamente.

16. Panel web

GOWA también proporciona una interfaz web.

Podemos acceder desde el navegador:

http://localhost:3000

El navegador solicitará las credenciales configuradas anteriormente:

Usuario: user1
Contraseña: pass1

17. Comprobar la versión

En nuestra instalación los logs mostraron:

v3.4.0

Además, el dashboard web fue descargado automáticamente:

[UI_ASSET] dashboard updated to v1.6.0

18. ¿Dónde se almacena SQLite?

La configuración utiliza:

DB_URI=file:storages/whatsapp.db?_foreign_keys=on

Por lo tanto, la base de datos queda dentro del volumen persistente:

/home/docker/gowa/
└── storages/
└── whatsapp.db

Esto es importante porque el archivo permanece aunque eliminemos el contenedor.

19. Comprobar los archivos creados

Podemos comprobar el contenido del directorio:

ls -lah storages

20. Comprobar el estado del contenedor

docker inspect gowa \
  --format '{{.State.Status}}'

Si todo funciona correctamente veremos:

running

21. Arquitectura final

                    ┌──────────────────────┐
                    │    Aplicación propia │
                    │                      │
                    │ Django / Python /    │
                    │ Java / REST API      │
                    └──────────┬───────────┘
                               │
                               │ HTTP
                               ▼
                    ┌──────────────────────┐
                    │         GOWA         │
                    │                      │
                    │     REST API         │
                    │      :3000           │
                    └──────────┬───────────┘
                               │
                               ▼
                         ┌───────────┐
                         │ whatsmeow │
                         └─────┬─────┘
                               │
                               ▼
                         ┌───────────┐
                         │ WhatsApp  │
                         └───────────┘

              ┌────────────────────────────┐
              │          SQLite            │
              │                            │
              │ storages/whatsapp.db       │
              └────────────────────────────┘

22. Configuración de Webhook

GOWA puede enviar eventos de WhatsApp a nuestra aplicación mediante webhooks. Esto permite construir bots.

Por ejemplo, podemos utilizar una aplicación Python:

WhatsApp
    │
    ▼
  GOWA
    │
    │ Webhook
    ▼
Django / FastAPI / Sanic
    │
    ▼
Lógica del bot
    │
    │ REST API
    ▼
  GOWA
    │
    ▼
WhatsApp

23. Ejemplo de un bot

Una arquitectura sencilla podría ser:

                MENSAJE EN WHATSAPP
                         │
                         ▼
                      GOWA
                         │
                    Webhook
                         │
                         ▼
              ┌───────────────────┐
              │   Python / Django │
              │                   │
              │ Procesa mensaje   │
              │                   │
              │ Genera respuesta  │
              └─────────┬─────────┘
                        │
                   HTTP REST
                        │
                        ▼
                      GOWA
                        │
                        ▼
                     WhatsApp

24. Comandos útiles

Detener GOWA:

docker stop gowa

Iniciar nuevamente:

docker start gowa

Reiniciar:

docker restart gowa

Ver logs:

docker logs -f gowa

Eliminar el contenedor:

docker rm -f gowa

Atención:
Eliminar el contenedor no elimina los datos almacenados en /home/docker/gowa/storages, porque ese directorio está montado como volumen Docker.

Conclusión

Con esta instalación tenemos GOWA ejecutándose dentro de Docker, utilizando SQLite para almacenar los datos y una API HTTP protegida mediante autenticación básica.

La aplicación queda preparada para utilizar WhatsApp desde aplicaciones externas como Django, Python o Java.

Siguiente paso:
El siguiente tutorial puede mostrar cómo vincular un número de WhatsApp mediante QR y posteriormente utilizar la API REST de GOWA para enviar y recibir mensajes.