¿Por qué este playbook?

• Pi-hole filtra anuncios y rastreadores a nivel de red, aumentando la velocidad de navegación y privacidad.
• Unbound te permite tener resolución DNS independiente, evitando entidades externas y acelerando las consultas.
• Ansible lo automatiza, permitiendo repetir la instalación o restaurarla tras un desastre en minutos.

Es una solución ideal si tienes un Raspberry Pi, un servidor casero, o quieres mejorar la gestión de red en oficinas pequeñas. Además, mantendremos todo modular y listo para crecer.

Playbook completo: despliega Pi-hole y Unbound

Copia este fichero site.yml en tu proyecto Ansible. Este playbook:

• Instala Docker y Docker Compose.
• Despliega Pi-hole como contenedor Docker.
• Despliega Unbound como contenedor Docker y lo enlaza a Pi-hole.
• Asegura persistencia de datos y expone la interfaz web de Pi-hole.

---
- name: Instala Pi-hole con Unbound usando Docker
  hosts: red_domestica
  become: true
  vars:
    pihole_web_port: 8080
    pihole_dns_port: 53
    unbound_dns_port: 5335
    pihole_timezone: Europe/Madrid
    pihole_web_password: "CAMBIAESTO"
    compose_dir: /opt/pihole_unbound
  tasks:
    - name: Instala docker y docker-compose
      apt:
        name:
          - docker.io
          - docker-compose
        state: present
        update_cache: true

    - name: Crea directorio para docker-compose
      file:
        path: "{{ compose_dir }}"
        state: directory
        owner: root
        group: root
        mode: 0755

    - name: Copia docker-compose.yml
      copy:
        dest: "{{ compose_dir }}/docker-compose.yml"
        content: |
          version: "3"
          services:
            pihole:
              image: pihole/pihole:latest
              container_name: pihole
              restart: unless-stopped
              environment:
                TZ: "{{ pihole_timezone }}"
                WEBPASSWORD: "{{ pihole_web_password }}"
                PIHOLE_DNS_: "{{ unbound_dns_port }}"
              ports:
                - "{{ pihole_web_port }}:80"
                - "{{ pihole_dns_port }}:53/tcp"
                - "{{ pihole_dns_port }}:53/udp"
              volumes:
                - ./etc-pihole/:/etc/pihole/
                - ./etc-dnsmasq.d/:/etc/dnsmasq.d/
              depends_on:
                - unbound

            unbound:
              image: mvance/unbound:latest
              container_name: unbound
              restart: unless-stopped
              ports:
                - "{{ unbound_dns_port }}:53/tcp"
                - "{{ unbound_dns_port }}:53/udp"
              volumes:
                - ./unbound:/opt/unbound/etc/unbound

          networks:
            default:
              name: pihole_unbound_net
              driver: bridge

    - name: Copia configuración mínima de Unbound
      copy:
        dest: "{{ compose_dir }}/unbound/unbound.conf"
        content: |
          server:
            verbosity: 1
            interface: 0.0.0.0
            port: 53
            do-ip4: yes
            do-udp: yes
            do-tcp: yes
            root-hints: "/opt/unbound/etc/unbound/root.hints"
            harden-glue: yes
            harden-dnssec-stripped: yes
            use-caps-for-id: yes
            edns-buffer-size: 1232
            prefetch: yes
            qname-minimisation: yes
            cache-min-ttl: 3600
            cache-max-ttl: 86400
            unwanted-reply-threshold: 10000
            num-threads: 2

    - name: Arranca los servicios con docker-compose
      shell:
        cmd: docker-compose up -d
        chdir: "{{ compose_dir }}"

    - name: Espera a que Pi-hole esté activo
      uri:
        url: "http://localhost:{{ pihole_web_port }}"
        status_code: 200
        timeout: 30
      register: result
      until: result.status == 200
      retries: 10
      delay: 5
    

Notas:
– Recuerda definir tus hosts en inventory bajo el grupo red_domestica.
– Cambia pihole_web_password por una contraseña segura.
– El puerto web se puede modificar libremente.

Primeros pasos tras la ejecución

1. Accede a http://tu-servidor:8080 y loguéate con tu contraseña.
2. En la configuración DNS de Pi-hole, pon 127.0.0.1#5335 para usar Unbound localmente.
3. ¡Redisfruta de una navegación más rápida y privada para todos tus dispositivos!

Consejos extra y troubleshooting

• ¡Cuidado con el firewall! Asegúrate de abrir los puertos 53/udp, 53/tcp y el web port si accedes desde fuera.
• Si tienes problemas de DNS, revisa que Unbound esté resolviendo correctamente:

  docker exec -it unbound dig google.es @127.0.0.1 -p 53

• Para actualizar Pi-hole o Unbound, basta con relanzar docker-compose pull seguido de docker-compose up -d en el directorio correspondiente.
• ¿Quieres añadir listas de bloqueo personalizadas? Usa la interfaz web de Pi-hole y ensaya.

¿Te gustaría extender el playbook con monitorización, tunneling o integración con Home Assistant? Dímelo en los comentarios, ¡me encantan los retos Ansible!