Automatización con Python y Ansible: gestión segura de claves SSH en entornos híbridos
Introducción
En entornos híbridos, donde coexisten servidores físicos on‑premises y máquinas virtuales en la nube, la gestión de claves SSH se vuelve un punto crítico de seguridad y operatividad. La rotación periódica de claves evita la reutilización indebida y reduce la superficie de ataque, mientras que la distribución controlada garantiza que sólo los usuarios y procesos autorizados tengan acceso.
Este artículo muestra cómo combinar Python (para generación y cálculo de huellas) y Ansible (para orquestación) y lograr un flujo completo de generación → rotación → distribución segura. Cada paso incluye comandos reales, fragmentos de configuración y la lógica detrás de cada decisión.
1. Generación automática de pares de claves SSH con Python
1.1. Por qué usar Python
Python permite crear scripts portables que no dependen de la presencia de ssh-keygen en el nodo de control. Además, con la biblioteca cryptography podemos definir el algoritmo (RSA, ECDSA, Ed25519) y el tamaño de clave de forma declarativa.
1.2. Instalación de dependencias
python3 -m venv venv
source venv/bin/activate
pip install cryptography
1.3. Script de generación
#!/usr/bin/env python3
import os
import base64
from pathlib import Path
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ed25519
def generate_keypair(key_name: str, out_dir: Path):
# Generamos una clave Ed25519 (más segura y ligera que RSA)
private_key = ed25519.Ed25519PrivateKey.generate()
public_key = private_key.public_key()
# Serializamos la clave privada en formato OpenSSH
priv_bytes = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.OpenSSH,
encryption_algorithm=serialization.BestAvailableEncryption(b\"$(openssl rand -base64 32)\"), # password aleatorio
)
# Serializamos la clave pública en formato autorizado
pub_bytes = public_key.public_bytes(
encoding=serialization.Encoding.OpenSSH,
format=serialization.PublicFormat.OpenSSH,
)
# Guardamos los archivos
priv_path = out_dir / f\"{key_name}\"
pub_path = out_dir / f\"{key_name}.pub\"
priv_path.write_bytes(priv_bytes)
pub_path.write_bytes(pub_bytes)
# Restricciones de permisos
os.chmod(priv_path, 0o600)
os.chmod(pub_path, 0o644)
return priv_path, pub_path
if name == “main”:
import argparse
parser = argparse.ArgumentParser(description=“Genera pares de claves SSH Ed25519.”)
parser.add_argument(“—name”, required=True, help=“Nombre base del par de claves”)
parser.add_argument(“—out”, default=”./keys”, help=“Directorio de salida”)
args = parser.parse_args()
out_dir = Path(args.out).expanduser().resolve()
out_dir.mkdir(parents=True, exist_ok=True)
priv, pub = generate_keypair(args.name, out_dir)
print(f\"Clave privada: {priv}\")
print(f\"Clave pública : {pub}\")</code></pre>
1.4. Explicación de los pasos críticos
- Ed25519: algoritmo moderno, 256‑bits, resistente a ataques de factorización y más rápido que RSA.
- Encriptación de la clave privada: se usa
BestAvailableEncryption con una contraseña aleatoria generada por OpenSSL; la contraseña se almacena temporalmente en un vault de Ansible (ver sección 3).
- Permisos: 600 para la privada (acceso exclusivo del propietario) y 644 para la pública.
2. Orquestación de la rotación con Ansible
2.1. Arquitectura del playbook
Dividimos el flujo en tres roles:
ssh_keygen: ejecuta el script Python y coloca las claves en files/.
ssh_distribute: copia la clave pública a los hosts objetivo y actualiza authorized_keys.
ssh_cleanup: revoca claves antiguas y elimina archivos temporales.
2.2. Inventario híbrido
# inventory.ini
[onprem]
srv01.example.com
srv02.example.com
[cloud]
ec2-3-12-45-67.compute-1.amazonaws.com
ec2-54-210-12-34.compute-1.amazonaws.com
[all:vars]
ansible_user=admin
ansible_ssh_private_key_file=~/.ssh/id_rsa_ansible
2.3. Playbook principal
---
- name: Rotación automática de claves SSH
hosts: all
become: true
vars:
key_name: "deploy_{{ inventory_hostname }}"
key_dir: "/tmp/ssh_keys"
roles:
- role: ssh_keygen
- role: ssh_distribute
- role: ssh_cleanup
2.4. Detalle del rol ssh_keygen
# roles/ssh_keygen/tasks/main.yml
- name: Crear directorio temporal
file:
path: "{{ key_dir }}"
state: directory
mode: '0700'
-
name: Ejecutar script Python de generación
command: >
{{ playbook_dir }}/scripts/gen_ssh_key.py
—name {{ key_name }}
—out {{ key_dir }}
args:
creates: ”{{ key_dir }}/{{ key_name }}”
name: Registrar rutas de las claves generadas
set_fact:
private_key_path: ”{{ key_dir }}/{{ key_name }}”
public_key_path: ”{{ key_dir }}/{{ key_name }}.pub”
2.5. Detalle del rol ssh_distribute
# roles/ssh_distribute/tasks/main.yml
- name: Guardar la clave pública en el host remoto
authorized_key:
user: "{{ ansible_user }}"
state: present
key: "{{ lookup('file', public_key_path) }}"
exclusive: false # no elimina otras claves válidas
-
name: Copiar clave privada cifrada al vault de Ansible delegate_to: localhost ansible.builtin.slurp: src: ”{{ private_key_path }}” register: private_key_content
name: Almacenar la clave privada en el vault (encriptado) ansible.builtin.copy: dest: ”{{ playbook_dir }}/vault/{{ inventory_hostname }}_id_ed25519.enc” content: ”{{ private_key_content.content | b64decode }}” mode: ‘0600’ when: private_key_content is defined
2.6. Detalle del rol ssh_cleanup
# roles/ssh_cleanup/tasks/main.yml
- name: Eliminar archivo de clave privada del nodo de control
file:
path: "{{ private_key_path }}"
state: absent
delegate_to: localhost
name: Eliminar directorio temporal file: path: ”{{ key_dir }}” state: absent delegate_to: localhost
3. Seguridad en la distribución: uso de Ansible Vault y SSH Agent
3.1. Por qué combinar Vault y ssh‑agent
La clave privada nunca debe viajar sin cifrar. Ansible Vault garantiza que el archivo .enc está encriptado con una contraseña fuerte. Para que los procesos automáticos (por ejemplo, pipelines CI/CD) la usen, cargamos la clave en ssh‑agent en tiempo de ejecución.
3.2. Creación del vault
# Crear un vault llamado secrets.yml
ansible-vault create vault/secrets.yml
# Dentro, guardamos:
private_key_password: "c0ntr4s3n4SegUr0!"
3.3. Desencriptado y carga en ssh‑agent
#!/bin/bash # load_key.sh – ejecutado por CI antes de cualquier playbook VAULT_PASS=$(ansible-vault view --vault-password-file .vault_pass vault/secrets.yml | grep private_key_password | awk '{print $2}') ENCRYPTED_KEY="vault/{{ inventory_hostname }}_id_ed25519.enc"Desencriptar temporalmente
ansible-vault view —vault-password-file .vault_pass “$ENCRYPTED_KEY” > /tmp/id_ed25519
chmod 600 /tmp/id_ed25519 ssh-add /tmp/id_ed25519 rm -f /tmp/id_ed25519
3.4. Buenas prácticas
- Limitar el alcance del vault a usuarios CI/CD mediante ACL de Git.
- Rotar la contraseña del vault cada 90 días usando
ansible-vault rekey. - Configurar
ssh-agentcon timeout corto (por ejemplo,SSH_AUTH_SOCK10 min).
4. Implementación en entornos híbridos (on‑prem y cloud)
4.1. Diferencias de acceso
Los servidores on‑prem suelen estar detrás de VPN o bastión, mientras que en la nube se accede mediante bastiones bastion hosts o mediante puertos restringidos a IPs de gestión. Ansible permite especificar ansible_ssh_common_args para cada grupo.
# inventory.ini (continuación)
[onprem:vars]
ansible_ssh_common_args='-o ProxyCommand="ssh -W %h:%p bastion.example.com"'
[cloud:vars]
ansible_ssh_common_args='-o StrictHostKeyChecking=no'
4.2. Uso de dynamic inventory para cloud
En AWS, aws_ec2 plugin genera el inventario automáticamente. Basta con agregar al ansible.cfg:
[defaults]
inventory = ./inventory.ini, ./aws_ec2.yml
4.3. Validación post‑rotación
Después de distribuir las claves, verificamos que sólo la nueva clave está presente en authorized_keys y que la antigua ha sido marcada como revocada.
- name: Validar que la clave nueva está presente
become: true
lineinfile:
path: "/home/{{ ansible_user }}/.ssh/authorized_keys"
regexp: "{{ lookup('file', public_key_path) | regex_escape }}"
state: present
name: Eliminar claves antiguas marcadas en el vault become: true shell: | grep -v -f {{ playbook_dir }}/vault/old_keys.txt /home/{{ ansible_user }}/.ssh/authorized_keys > /tmp/ak.tmp &&
mv /tmp/ak.tmp /home/{{ ansible_user }}/.ssh/authorized_keys
5. Troubleshooting y errores comunes
5.1. “Permission denied (publickey)” al ejecutar el playbook
- Causa: La clave privada no está cargada en
ssh-agento el agente no tiene la clave correcta. - Solución: Ejecutar
ssh-add -lpara listar claves cargadas; si falta, usarload_key.sho importar manualmente.
5.2. Ansible falla al leer authorized_keys
- Causa: Permisos de
.sshoauthorized_keysdemasiado abiertos (por ejemplo, 777). - Solución: Asegurarse de que la carpeta tenga
0700y el archivo0644. Ansible puede corregirlo confilemodule antes de añadir la clave.
5.3. El script Python genera una clave sin contraseña
- Causa: Variable de entorno
$(openssl rand -base64 32)no se expande dentro de Python. - Solución: Reemplazar por
os.urandom(32)dentro del script o pasar la contraseña como argumento.
5.4. Errores de “Host key verification failed” en hosts cloud
- Causa: El host nunca se ha añadido al
known_hostsdel controlador. - Solución: Añadir
ansible_ssh_common_args='-o StrictHostKeyChecking=no'temporalmente o ejecutarssh-keyscanantes del playbook.
5.5. Clave pública no se refleja en authorized_keys
- Causa: Variable
public_key_pathno está disponible en el host remoto porque el task se ejecutó condelegate_to: localhostsin registrar. - Solución: Asegurarse de usar
set_factdespués del task de generación y que el scope sea *host* (no *local*).
Conclusión
Automatizar la generación, rotación y distribución de claves SSH con Python y Ansible brinda seguridad, consistencia y velocidad en entornos híbridos. La combinación de un script Python fiable, roles Ansible bien estructurados y el uso correcto de Ansible Vault/ssh‑agent protege tanto los activos on‑prem como los recursos en la nube.
Implementar este flujo permite cumplir con políticas de cumplimiento (PCI‑DSS, ISO 27001) que exigen rotación periódica de credenciales, al mismo tiempo que elimina el error humano típico de la gestión manual. Ajusta los tamaños de clave, los intervalos de rotación y la integración con tu pipeline CI/CD para obtener una solución a prueba de futuro.