Acerca de Jose Antonio

Yo soy el que manda aqui... ¿Que pasa?

La IA más barata para generar código

Llevo desde casi el principio de toda esta vorágine utilizando github copilot, inicialmente con el modelo único que nos proporcionaba y recientemente en modo agente con claude sonnet y es lo mejor que he probado hasta el momento. Pero los 10 euros del copilot llegan hasta donde llegan y cuando se agota el crédito que tienes para usar claude con copilot te quedas un poco huerfano y es como si tu asistente se hubiese ido de vacaciones… Entonces me puse a buscar lo que costaría tener acceso extra a claude para cuando esto pasaba… Y resulta que son 20 eurazos al mes en su plan básico.

No parece mucho, pero si ya pagas copilot y no quieres pagar un extra tan alto solo para los días que se acaban los créditos de claude, pues se hace un poco cuesta arriba. Así que me puse a buscar qué otras opciones teníamos que fuesen, digamos, un poco más económicas y tuviesen un resultado similar al que te da claude. Y resulta que me topé con glm

Por 3 dolares al mes (contraté el trimestral para probar) dicen que tienen un modelo similar en potencia a claude sonnet 4. Lo que vamos a ver aquí es como utilizar este modelo con el agente claude code que tiene un comportamiento similar a github copilot y que permite, entre otras cosas, interactuar con MCPs. No es un proceso tan complicado, así que os dejo aquí cómo hacerlo:

Lo primero que vamos a necesitar es la clave API de GLM, para eso (suponiendo que os habéis suscrito, que si no nada de esto sirve), os vais a la sección de API keys

Y ahí creais una nueva API KEY. No os preocupeis que podréis copiarla después de haberla creado, no es como en otros sitios que solo te la muestran una vez. Guardad esa API key que la vais a necesitar después. Por cierto, tienen muy buena documentación sobre todo esto en su página web: https://docs.z.ai/guides/overview/quick-start

Lo siguiente que tienes que hacer es instalar claude code, esto suele ser bastante sencillo y bastaría con ejecutar esto (suponiendo que tienes una versión de node >= 18 en tu ordenador):

npm install -g @anthropic-ai/claude-code

Una vez instalado ejecutalo para que se creen los archivos de configuración (y eliges ya de paso el tema)

Luego, como no vamos a usar la cuenta de anthropic, simplemente damos ctrl-c varias veces para salir. Pero con ello ya se nos han creado los directorios de configuración y podemos editarlos.

Pon lo siguiente en el archivo ~/.claude/settings.json

{
    "env": {
        "ANTHROPIC_AUTH_TOKEN": "el api key de glm",
        "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
    	"ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.6",
        "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-4.6"
    }
}

Luego nos vamos a cualquier directorio en el que tengamos código y querramos trabajar y ejecutamos el comando claude

Le decimos que si le damos permiso y ya podremos utilizar claude code con glm (lo podemos comprobar en la parte superior)

Y ya podemos usar el agente de claude con el modelo glm y ver qué tal se le da… En mis pruebas lo ha hecho bastante bien, aunque el interfaz es bastante más espartano que el de github copilot no le falta ninguna de las funcionalidades.

Por ahora disfrutad con esto (lo puedes lanzar desde dentro de un terminal de vscode y lo detecta y se integra con el ide) y en la siguiente entrada ya os digo como acceder a MCPs usando este agente y este modelo.

La herramienta correcta para gestión de tareas

Cualquier equipo, se dedique a lo que se dedique, cuando lo componen varias personas hay un momento en que alguien debe pararse y decir, ¿estamos haciendo las cosas bien? ¿en el orden correcto? ¿dedicando el tiempo necesario a cada una? ¿tenemos controlado el trabajo o el trabajo nos controla a nosotros? Lo que antes eran reuniones y encargos sencillos se ha convertido en un sin fin de recordatorios de cosas que no se han hecho, se han hecho sin necesidad o se han hecho demasiado tarde o demasiado pronto. En este punto es cuando la elección de una buena herramienta de gestión de tareas se hace necesaria.

Si esperáis que os diga cual es la correcta para el desarrollo de software, bueno, pues os equivocáis, todavía no he encontrado la que sea perfecta, pero si que puedo ofreceros mi visión sobre lo que necesitaría tener esa herramienta y los intentos de encontrarla que he tenido durante estos casi 30 años en el oficio.

Primero lo primero, cuales son las necesidades que queremos cubrir con esta herramienta:

  • Queremos poder registrar el tiempo dedicado y estimado para cada tarea sin que nos quite tiempo de trabajo efectivo.
  • Necesitamos saber la prioridad de las distintas tareas y poder ordenarlas en el tiempo.
  • Necesitamos saber quien tiene que trabajar en una tarea y qué es lo que tiene que hacer en la misma
  • Necesitamos saber el estado de cada tarea y el grado de avance general de la tarea y del proyecto al que pertenece
  • Es preciso poder descomponer el trabajo en tareas más pequeñas que puedan ser abordadas por una sola persona o, en el caso de requerir múltiples participantes al mismo tiempo que esté controlado el tiempo dedicado por cada persona
  • Queremos que cada proyecto tenga una visión clara de las tareas en curso y las que están en distintos estados del workflow de desarrollo
  • Necesitamos que haya una trazabilidad completa de las tareas desde su creación hasta que esta se termina
  • Es imprescindible disponer de documentación y una forma de asociarla a las tareas, pero de manera más independiente ya que la documentación ha de permanecer más allá de la vida de la tarea
  • Se necesita una manera ágil de comunicación entre los distintos componentes del equipo y, posiblemente, con elementos fuera de los equipos de desarrollo (usuarios, QA, dirección) aunque no es imprescindible que esté ligado al mismo sistema si que se necesita una manera sencilla de referirse a las tareas externamente.
  • Es deseable poder implementar distintos ciclos de vida a distintos tipos de proyectos y no limitarse a uno solo.
  • Si se usa un sistema el directorio de usuarios debe estar en sincronía con el de la empresa y la autenticación deberá ser compatible con la existente.

Evidentemente cada organización, empresa o grupo puede tener más o menos necesidades, pero en la lista anterior creo que he incluido las principales. El objetivo final es saber qué trabajo queda por hacer, qué hacer primero, tener previsiones de cuando estará un cierto trabajo complejo y saber cómo se están aprovechando los recursos. Obviamente cuanto más sencillo sea el sistema y cuanto menos tiempo nos quite de las tareas reales más efectivo será.

Y, para que sirva de referencia os voy a contar mi historia con los distintos sistemas de gestión de tareas que he tenido el «honor» de probar.

En el 97 empecé a trabajar profesionalmente en esto de la informática después de haber terminado la carrera y haber obtenido toda la teoría necesaria sobre gestión de proyectos y haber hecho un curso de CEPADE sobre gestión de proyectos tecnológicos. En la empresa en la que entré se gestionaba todo con Microsoft Project, por suerte generalmente la planificación moría en el momento en que el proyecto empezaba. Lo único que se esperaba respetar eran los plazos y los entregables. El tiempo dedicado no se actualizaba nunca y solo se ampliaban los plazos o, si el cliente se ponía pegigero, se cambiaba el alcance y se eliminaban o añadían tareas sin demasiado control.

Microsoft desarrolló una especie de project on-line para que los usuarios que estuviesen participando en un proyecto pudiesen imputar las horas o indicar cuando se habían acabado las tareas. Ahora mismo no recuerdo el nombre del producto, lo que si recuerdo es que era tan dificil de instalar y hacer funcionar correctamente que lo usamos solo en un proyecto antes del olvidarlo completamente. Project se quedó para el papeleo y marcar las fechas esperadas y controlar, por tanto, el retraso de las tareas y del proyecto en general.

Seguí usando project (sin ningún online y con control mediante arcaicas hojas excel) hasta que evolucioné lo suficiente (y puse mi propia empresa) como para usar Linux como mi máquina principal… Mira por donde ahí no había forma de ejecutar el project y me las vehía y deseaba para generar los gantt de manera medianamente atractiva para presentársela a los clientes (si, ya era para mis propios clientes). Llegados a este punto descubrí una herramienta online que, aunque inicialmente no creada para ello, servía perfectamente para hacer seguimiento del tiempo dedicado a las tareas de un proyecto, se trataba de trac. Tal como contaba en su página (hoy casi abandonada)

Trac es un sistema wiki mejorado y de seguimiento de incidencias para proyectos de desarrollo de software. Trac utiliza un enfoque minimalista para la gestión de proyectos de software basados en la web.

trac era un sistema de tickets, con un wiki para la documentación y conexión con subversion para el control de código. Si a esto le unimos que permitía indicar el número de horas dedicadas a cada incidencia, ya teníamos una primera forma de controlar en tiempo real las tareas. El wiki no era perfecto y la búsqueda también podía mejorarse, pero cumplió muy bien con su cometido durante unos cuantos años. De hecho el problema sobrevino cuando dejaron de mantener el producto y ya teníamos muchos proyectos gestionados con este sistema. Tengo que decir que antes de llegar a trac (que inicialmente se llamó svntrac) estuvimos usando cvstrac y cvs en lugar de subversion… Y si, tuvimos que migrar de cvs a subversion y de eso a git (es lo que tiene llevar más de 20 años produciendo código sin querer perder nada).

El caso es que descubrimos un poco después que había un programa que tenía todo lo que tenía trac (y algunas cosas más) que era completamente software libre y, además, rapidísimo y se llama Redmine. Aunque lleva creado desde 2006 no fue hasta 2018 que decidí implantarlo en mi empresa (y en la de algún cliente posteriormente). Aunque seguía sin ser perfecta nos ofrecía todo lo que necesitábamos para el control de tareas, nos permitía comunicarnos con los clientes via incidencias, llevar un tracking completo de todo en lo que hemos trabajado de cada proyecto, con múltiples proyectos completamente aislados unos de otros y con usuarios igualmente aislados y con roles diferenciados. Todos nuestros proyectos con mantenimiento se iniciaban como proyecto redmine y evolucionaba a proyecto de mantenimiento abierto a que los clientes pudieran dar de alta sus incidencias y hacer seguimiento de la evolución del mismo.

El mayor problema de redmine es que tremendamente poco intuitivo o, dicho en castellano «es feo de cojones». Aunque tiene todo lo que necesitamos para un equipo de desarrollo (aunque feo-feo), es imposible a día de hoy intentar que un cliente entre por el aro de reonocer esto como una aplicación web… Ahora se espera utilizar llamativos tableros kanvan (inutilizables cuando el número de tareas es alto o los equipos grandes) y modificaciones instantaneas via clicks y sin tener que escribir nada, solo pinchar y arrastrar. Me he pasado los últimos años buscando herramientas software libre que me permitiesen tener la misma privacidad y funcionalidad que redmine pero con un aspecto nuevo y renovado. He probado desde Trello hasta monday.com pasando por Jira y Asana (igual Jira no es tampoco demasiado atractivo). Quitando que ninguna de estas herramientas son libres de verdad y varias de ellas o son demasiado completas o carecen de alguna de las características que hemos descrito anteriormente todas ellas son carísimas… Sigo buscando ya que aunque redmine me viene bien para gestionar un equipo de desarrollo se atraganta a otro tipo de perfil menos hecho a lidiar con informes y formularios. ¿Conocéis alguno bueno y, a ser posible, open source o con una versión realmente barata?

Escribiendo código con una sola mano

Hace unos días he sufrido un desafortunado accidente que ha terminado con el 5º metatarso de mi mano izqierda fracturado. Eso significa que voy a estar de 3 a 8 semanas sin poder usar mi mano izquierda para nada.

El caso es que nunca pensé que echaría de menos tanto a mi mano izquierda pero, en serio, ahora me siento como menos capaz de hacer las mismas cosas que hacía antes, aunque no interviniese para nada la mano izquierda. Yo siempre he dicho que programar es un oficio de cabeza, no de teclas… Pero no veas cómo ayuda poder escribir rápido lo que estás pensando.

La mano izquierda es solo una herramienta, pero una que nos permite hacer mejor y más rápido lo que ya sabemos hacer… Casi como la IA.

Yo estoy suscrito a github copilot casi desde el principio (antes de que lo abriesen al público ya había hecho mis pruebas), como copiloto que te completa las líneas o que escribe por tí las aburridas funciones que le describes, o incluso que adivina lo siguiente que quieres hacer en el archivo en base a lo que ya has escrito antes, era fantástco, una herramienta de la que no te podías fiar 100% pero que te ahorraba muchas horas de búsquedas y pruebas. Pero es que el otro día probé el modo agente (usando claude sonnet 4) y la cabeza casi me estalla…

Había probado antes firebase studio de google, que intenta hacer un desarrollo completo de aplicación de manera visual y en base a instrucciones que le vas dando a la IA y, realmente, me gustó mucho el concepto, la pena es que solo sirve en ese modo para hacer aplicaciones React y yo necesitaba algo más flexible.. Y lo encontré en el modo agente de github copilot

Modo agente de copilot

Puedes usarlo en cualquier proyecto que ya tengas en visual studio code o puedes empezar uno de cero y con unas pocas instrucciones puedes crear el tipo de proyecto que quieras, tanto de front como de back, en el lenguaje que quieras y con el framework que quieras… Y no, no es vibe coding como tal, es una herramienta más que te sirve para ir dando forma y corrigiendo el proyecto en un entorno controlado por ti.

Y lo más flipante es que te explica lo que va a hacer y las ventajas que te da… Y escribe documentación para acompañar… Y además en tu idioma. Solo por eso ya es una herramienta muy valiosa. Pero, lo que es más, te ayuda a comprender que cuanto más claros y detallados están los requisitos más fácil es que lo que obtengas se parezca a lo que querías (igual a nuestros clientes hay que ponerles a hacer vibe coding para que empiecen a aprender a pedirnos las cosas).

Otra cosa muy interesante es poder seguir el razonamiento para arreglar problemas de una manera natural (en azul lo que le digo yo)

La imagen corresponde a un proyecto todavía en marcha, sin embargo puedo poneros como ejemplo un programa que ha desarrollado 100% github copilot (con mi dirección y correcciones). Tenéis todo el código en el repositorio: https://github.com/yoprogramo/imaphp

Ultimamente me he dedicado mucho a hospedar mis propios servidores, aprovechando que estaba probando proxmox. Uno de los servicios qu quería probar era el de servidor de correo e instalé Stalwart, un sistema muy completo y que, a lo mejor, os explico un día como instalar. Tiene multitud de servicios, no solo el de SMTP, sino IMAP, POP, CalDAV, Antispam, etc… Pero algo que no tiene es un cliente webmail. Me puse a buscar a ver si encontraba alguno que no tuviese dependencias y no me gustó ninguno, así que dije.. ¿Qué carajo? Vamos a escribir uno.

Y me puse manos a la obra, decidí que quería que fuese lo más ligero posible y que pudiese ejecutarse en cualquier sitio (docker incluido) y comencé el proyecto de cero usando el modo agente del copilot.

Para poder probarlo de la manera rápida, montad este docker-compose.yml:

services:
  imap-client:
    image: yoprogramo/imaphp:1.0.0
    ports:
      - "8888:80"
    environment:
      - PHP_DISPLAY_ERRORS=Off
      - PHP_ERROR_REPORTING=E_ERROR
    volumes:
      - ./data:/var/www/html/data
    restart: always

Crea un directorio data y dale los permisos para que todo el mundo pueda escribir y lánza el compose:

docker compose up -d

Ahora simplemente accede a http://localhost:8888 (puedes cambiar el puerto en el compose) y verás que se te invita a dar de alta un servidor

Y luego ya podrás entrar con tu usuario imap

Y, finalmente, acceder a tu correo:

Y con esto un pequeño ejemplo del tipo de cosas que se pueden pedir a las IAs de programación actualmente… Pero esto corre que se las pela, lo bueno es que siempre necesitaras a un humano de verdad que entienda lo que está haciendo y cómo arreglarlo.

Cómo Configurar Login con Office 365 (Microsoft Entra ID) en Authentik

Como ya vimos en la anterior entrada es bastante sencillo instalar un sistema SSO como authentik en nuestra infraestructura. De todas formas, crear un login centralizado no es más que una manera de tener que recordar menos contraseñas, pero el objetivo final es no tener que recordar más que unas pocas para poder acceder a todos los servicios, ¿qué hacemos si ya tenemos cuenta en alguno de los servicios más populares como office 365 o google? Lo suyo sería poder hacer login con estas credenciales en cualquier servicio, sea online o sea auto hospedado. Por suerte, authentik puede hacer uso de estos servicios externos de autenticación de manera «relativamente» sencilla. En este post os voy a explicar paso a paso (que sobre todo la parte a realizar con office es un poco liosa) cómo integrar el login de office 365 con authentik y así poder usarlo para acceder a nuestras aplicaciones (eso ya lo explicaremos en próximos posts).

Para poder realizar este tutorial debes tener:

  • Servidor authentik instalado y configurado (con acceso como administrador)
  • Cuenta de administrador office365 de tu organización
  • Un poco de paciencia (esto nunca viene mal)

Paso 1: registrar una aplicación de microsoft entra

Entramos como administrador en portal.office.com

Pedimos que nos muestre todas las opciones (estos de MS suelen ocultarnos cosas)

Seleccionamos la opción Identidad (nos llevará a entra)

Seleccionamos la opción Registro de aplicaciones

Y seleccionamos Nuevo registro

Y rellenamos los datos básicos (yo voy a llamar authentik a la nueva aplicación)

Hemos elegido que solo se pueda entrar con cuentas de nuestra organización, que será lo normal, aunque si queremos que cualquiera que tenga una cuenta de office365 pueda hacer logn tendremos que escoger una de las otras opciones. Atento a la ui de redirección, en principio tendrá el formato https://<direccion-de-tu-authentik>/source/oauth/callback/<nombre-de-fuente> Si no lo configuras ahora lo podrás hacer después cuando termines la configuración en authentik.

Anotamos los datos que vamos a necesitar de la aplicación y creamos un nuevo secreto:

Es muy importante que copiemos el valor del secreto que lo vamos a necesitar luego

El valor del secreto no se va a poder copiar en otro momento, mejor que lo guardes ahora.

Con esto hemos terminado (en principio) con la configuración necesaria en el portal de office. Lo que hemos hecho, básicamente, es configurar los endpoints de oauth2 que podemos consultar en la opción.

Paso 2: crear un nuevo login social

Las siguientes acciones las haremos como administrador en nuestro servidor authentik

El primer paso es crear un inicio de sesión federado

del tipo azure AD

Ahora deberemos introducir todos los datos que hemos guardado al crear la aplicación en entra:

Los endpoint serán como estos (revisar los que vimos en la pantalla del portal de office):

Cambiaremos la URL del perfil a https://graph.microsoft.com/oidc/userinfo

Y damos a terminar por ahora. Esto nos configura el método para entrar usando las credenciales de Microsoft, pero todavía nos falta un par de cosas para que sea útil del todo.

Paso 3: mapeo de atributos

Ahora necesitamos hacer la equivalencia entre los atributos que vienen de office con los que nosotros vamos a utilizar en nuestro directorio, para eso crearemos una política de expresión:

La llamamos (por ejemplo) azure-ad-mapping y ponemos este contenido:

# save existing prompt data
current_prompt_data = context.get('prompt_data', {})
# make sure we are used in an oauth flow
if 'oauth_userinfo' not in context:
  ak_logger.warning(f"Missing expected oauth_userinfo in context. Context{context}")
  return False
oauth_data = context['oauth_userinfo']
# map fields directly to user left hand are the field names provided by
# the microsoft graph api on the right the user field names as used by authentik
required_fields_map = {
  'name': 'username',
  'email': 'email',
  'given_name': 'name'
}
missing_fields = set(required_fields_map.keys()) - set(oauth_data.keys())
if missing_fields:
  ak_logger.warning(f"Missing expected fields. Missing fields {missing_fields}.")
  return False
for oauth_field, user_field in required_fields_map.items():
  current_prompt_data[user_field] = oauth_data[oauth_field]
# Define fields that should be mapped as extra user attributes
attributes_map = {
  'name': 'upn',
  'sub': 'sn',
  'name': 'name'
}
missing_attributes = set(attributes_map.keys()) - set(oauth_data.keys())
if missing_attributes:
  ak_logger.warning(f"Missing attributes: {missing_attributes}.")
  return False
# again make sure not to overwrite existing data
current_attributes = current_prompt_data.get('attributes', {})
for oauth_field, user_field in attributes_map.items():
  current_attributes[user_field] = oauth_data[oauth_field]
current_prompt_data['attributes'] = current_attributes
context['prompt_data'] = current_prompt_data
return True

Paso 4: configurar el flujo de alistamiento

Queremos que cualquiera que tenga cuenta en el dominio office pueda entrar a nuestras aplicaciones, por lo que necesitamos registrar los usuarios nuevos cuando entran por primera vez, para ello vamos a crear uun flujo nuevo.

Le ponemos un nombre

Y una vez creado, editarlo, ir a la sección d Vinculaciones de Políticas / Grupos / Usuarios y ahí a Bind existing policy

Y ahí ligar defaultsource-enrollment-if-sso

Ir ahora a vinculos de etapa -> Bind Existing stage

Añadir default-source-enrollment-write (orden 0) y default-source-enrollment-login (orden 10)

Desplegar luego la etapa con orden cero y añadir una política existente azur-ad-mapping que creamos antes:

Por último editarmos la fuente que creamos al principio (Directory -> Federation ..) y le añadimos en la configuración de flujo el flujo de inscrpción a azure-ad-enrollment (o el nombre que le hayamos puesto)

Paso 5: hacer que se vea en el login

Pues ya solo nos faltaría hacer que aparezca una opción para hacer login con este proveedor, esto se hace editando el flujo default-authentication-flow

Y editas la etapa

Y añades desde las fuentes disponibles a Fuentes seleccionadas

Ahora cuando entres en tu authentik ya te aparecerá la opción nueva para acceder. La primera vez que accedas debes aprobar unos permisos especiales a Microsoft:

Ha sido un proceso un poco largo, pero ahora ya tenéis centralizada la información de seguridad y cualquier aplicación que pueda conectarse a authentik podrá usar los usuarios de nuestro dominio… Ahora queda que lo probéis vosotros.

Instala tu propio servidor SSO (Single Sing-On)

Es posible que, como nosotros, ester harto de tantas contraseñas y tantas veces que tienes que autenticarte para acceder a tus aplicaciones. Nosotros ya inventamos nomorepass para no tener que andar recordando la contraseñas, pero eso no quita a que cada vez que instalamos un nuevo sistema en nuestro laboratorio personal nos toque volver a lidiar con las credenciales de acceso. Hay veces que intentamos centralizarlo en algún proveedor externo (como google o microsoft), pero esto no es del todo seguro y corremos el riesgo de tener que andar configurando nuestras aplicaciones con credenciales que, como las de Microsoft Hello caducan cada cierto tiempo.

Por eso os propongo algo mejor, ¿porqué no hospedar nosotros nuestro propio sistema de autenticación? En este post vamos a ver como instalar y configurar uno de los más populares y potentes sistemas SSO: Authentik. La instalación es bastante sencilla y está bien explicada en su documentación. Os resumo cómo quedaría la cosa. Necesitamos:

  • Servidor donde instalarlo (2VCPU / 2Gb memoria mínimo)
  • Docker y docker compose (v2 mejor)
  • wget y openssl instalado (necesarios solo para la instalación)

Una vez que tenemos el servidor con docker y docker compose instalado nos descargamos la plantilla:

wget https://goauthentik.io/docker-compose.yml

Y generamos los elementos de seguridad necesarios y los guardamos en el archivo .env

echo "PG_PASS=$(openssl rand -base64 36 | tr -d '\n')" >> .env
echo "AUTHENTIK_SECRET_KEY=$(openssl rand -base64 60 | tr -d '\n')" >> .env

Con esto ya podemos arrancar el servidor. Hay cosas que sería recomendable configurar, como la salida de email, bien con un servidor propio, o podéis utilizar cualquier servicio que os ofrezca smtp. También se puede cambiar el puerto por el que se accede, que generalmente está en el 9000/9443 para cambiarlos a los estándar 80/443. Como ejemplo os dejo mi docker-compose y mi .env (cambiando las cosas privadas, claro):

services:
  postgresql:
    image: docker.io/library/postgres:16-alpine
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -d $${POSTGRES_DB} -U $${POSTGRES_USER}"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 5s
    volumes:
      - database:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: ${PG_PASS:?database password required}
      POSTGRES_USER: ${PG_USER:-authentik}
      POSTGRES_DB: ${PG_DB:-authentik}
    env_file:
      - .env
  redis:
    image: docker.io/library/redis:alpine
    command: --save 60 1 --loglevel warning
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      start_period: 20s
      interval: 30s
      retries: 5
      timeout: 3s
    volumes:
      - redis:/data
  server:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.4}
    restart: unless-stopped
    command: server
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
    volumes:
      - ./media:/media
      - ./custom-templates:/templates
    env_file:
      - .env
    ports:
      - "${COMPOSE_PORT_HTTP:-9000}:9000"
      - "${COMPOSE_PORT_HTTPS:-9443}:9443"
    depends_on:
      postgresql:
        condition: service_healthy
      redis:
        condition: service_healthy
  worker:
    image: ${AUTHENTIK_IMAGE:-ghcr.io/goauthentik/server}:${AUTHENTIK_TAG:-2025.2.3}
    restart: unless-stopped
    command: worker
    environment:
      AUTHENTIK_REDIS__HOST: redis
      AUTHENTIK_POSTGRESQL__HOST: postgresql
      AUTHENTIK_POSTGRESQL__USER: ${PG_USER:-authentik}
      AUTHENTIK_POSTGRESQL__NAME: ${PG_DB:-authentik}
      AUTHENTIK_POSTGRESQL__PASSWORD: ${PG_PASS}
    user: root
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./media:/media
      - ./certs:/certs
      - ./custom-templates:/templates
    env_file:
      - .env
    depends_on:
      postgresql:
        condition: service_healthy
      redis:
        condition: service_healthy

volumes:
  database:
    driver: local
  redis:
    driver: local

.env:

PG_PASS=<esto-lo-tienes-que-generar>
AUTHENTIK_SECRET_KEY=<esto-lo-generas-tambien>
AUTHENTIK_ERROR_REPORTING__ENABLED=true
# SMTP Host Emails are sent to
AUTHENTIK_EMAIL__HOST=mail.biblioeteca.net
AUTHENTIK_EMAIL__PORT=587
[email protected]
AUTHENTIK_EMAIL__PASSWORD=<el que sea>
AUTHENTIK_EMAIL__USE_TLS=false
AUTHENTIK_EMAIL__USE_SSL=false
AUTHENTIK_EMAIL__TIMEOUT=10
[email protected]
AUTHENTIK_TAG=2025.6.2

Si todo hay ido bien ya puedes arrancarlo:

docker compose up -d

Y ya puedes empezar a configurar tu nuevo SSO navegando a la página:

http://<IP servidor>:9000/if/flow/initial-setup/

Con esto ya tenemos un sistema que nos permite hacer login con los usuarios que queramos… ¿Qué más podemos hacer con este sistema?… Pues un montón de cosas. Quedaos atentos y en los siguientes posts os enseñaré como hacer cosas interesantes como conectar con sistemas externos (como office365 o google) y hacer uso de esas credenciales.