# Restricción de Acceso SSH con SSSD y Grupos de Active Directory usando Ansible

- Link: https://binariocero.com/ansible/restriccion-de-acceso-ssh-con-sssd-y-grupos-de-active-directory-usando-ansible
- Published: 2025-08-09T13:06:37+02:00
- Author: Juan José Fernández Durán

![Loading](https://binariocero.com/wp-content/plugins/page-views-count/ajax-loader-
2x.gif)

En entornos corporativos donde la autenticación centralizada es esencial, integrar
sistemas Linux con Active Directory (AD) mediante **SSSD (System Security Services
Daemon)** permite una administración eficiente y segura. Además, limitar el acceso
SSH únicamente a los usuarios de un grupo de AD específico mejora la postura de 
seguridad del sistema.

Este artículo describe cómo automatizar esta configuración usando **Ansible**, gestionando
tanto sistemas **Debian/Ubuntu** como **CentOS/RHEL**, para:

 * Instalar los paquetes necesarios.
 * Configurar el servicio `sssd`.
 * Activar la creación automática de directorios home (`mkhomedir`).
 * Restringir el acceso SSH según pertenencia a un grupo de AD.

### Requisitos previos

 * Nodo gestionado unido previamente a Active Directory (por ejemplo, usando `realm
   join`).
 * Inventario de Ansible con privilegios de root.
 * Variables definidas:
    - `ad_domain`: dominio AD (ej. `empresa.local`)
    - `realm`: nombre del realm Kerberos (ej. `EMPRESA.LOCAL`)
    - `ad_group`: nombre del grupo de AD autorizado
    - `ou_filter`: ruta DN de la OU (ej. `OU=Grupos,DC=empresa,DC=local`)
    - `pam_common_session`, `sssd_config_path`, y `sshd_config`: rutas adaptadas
      a la distribución

### Playbook de Ansible

A continuación se presenta el playbook completo:

    ```wp-block-code
    ---
    - name: Configurar acceso SSH mediante SSSD y grupo de AD
      hosts: all
      become: true
      vars:
        ad_domain: empresa.local
        realm: EMPRESA.LOCAL
        ad_group: sshusers
        ou_filter: OU=Grupos,DC=empresa,DC=local
        pam_common_session: /etc/pam.d/common-session
        sssd_config_path: /etc/sssd/sssd.conf
        sshd_config: /etc/ssh/sshd_config

      tasks:

        - name: Detectar distribución
          ansible.builtin.setup:
            gather_subset: min

        - name: Instalar paquetes en Debian/Ubuntu
          ansible.builtin.apt:
            name:
              - sssd
              - sssd-tools
              - libnss-sss
              - libpam-sss
              - oddjob
              - oddjob-mkhomedir
            state: present
            update_cache: yes
          when: ansible_facts['os_family'] == "Debian"

        - name: Instalar paquetes en RHEL/CentOS
          ansible.builtin.yum:
            name:
              - sssd
              - sssd-tools
              - oddjob
              - oddjob-mkhomedir
              - authselect
            state: present
          when: ansible_facts['os_family'] == "RedHat"

        - name: Activar mkhomedir en Debian/Ubuntu
          ansible.builtin.lineinfile:
            path: "{{ pam_common_session }}"
            line: "session required pam_mkhomedir.so skel=/etc/skel umask=0077"
            state: present
          when: ansible_facts['os_family'] == "Debian"

        - name: Activar mkhomedir en RHEL/CentOS
          ansible.builtin.command: authselect select sssd with-mkhomedir --force
          when: ansible_facts['os_family'] == "RedHat"
          ignore_errors: true

        - name: Configurar archivo sssd.conf
          ansible.builtin.template:
            dest: "{{ sssd_config_path }}"
            mode: '0600'
            content: |
              [sssd]
              domains = {{ ad_domain }}
              config_file_version = 2
              services = nss, pam, ssh

              [domain/{{ ad_domain }}]
              ad_domain = {{ ad_domain }}
              krb5_realm = {{ realm }}
              realmd_tags = manages-system joined-with-samba
              cache_credentials = True
              id_provider = ad
              access_provider = ldap
              ldap_access_order = filter
              ldap_access_filter = (memberOf=CN={{ ad_group }},{{ ou_filter }})
              default_shell = /bin/bash
              fallback_homedir = /home/%u
              ldap_id_mapping = true

        - name: Reiniciar SSSD
          ansible.builtin.service:
            name: sssd
            state: restarted
            enabled: true

        - name: Asegurar que UsePAM yes está en sshd_config
          ansible.builtin.lineinfile:
            path: "{{ sshd_config }}"
            regexp: "^UsePAM"
            line: "UsePAM yes"
            state: present

        # - name: (Opcional) Restringir también con AllowGroups en SSH
        #   ansible.builtin.lineinfile:
        #     path: "{{ sshd_config }}"
        #     line: "AllowGroups domain^{{ ad_group }}@{{ realm }}"
        #     state: present

        - name: Reiniciar SSH
          ansible.builtin.service:
            name: sshd
            state: restarted
            enabled: true
    ```

### Consideraciones adicionales

 * **Seguridad del archivo `sssd.conf`**: debe tener permisos 0600 o el servicio
   fallará.
 * **`mkhomedir`**: garantiza que al iniciar sesión por primera vez, el usuario 
   de AD tendrá su directorio `/home` creado automáticamente.
 * **`ldap_access_filter`**: permite un control granular del acceso mediante un 
   filtro LDAP, muy útil si quieres limitar aún más a nivel de grupo/OU.
 * **`AllowGroups` en SSH** (comentado): útil como doble validación si quieres añadir
   una capa más restrictiva al servicio SSH.

### Conclusión

Automatizar la restricción de acceso SSH mediante Ansible, SSSD y Active Directory
permite a los equipos de IT estandarizar configuraciones críticas de seguridad de
forma eficiente. Esta metodología resulta especialmente útil en entornos híbridos
o con múltiples servidores donde se requiere control de acceso centralizado.