StefanMewes/Nebula-Ansible-Role
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
53c9eba7d2d17f3a719dbab3b8b5f3aecae6ecc4
Nebula-Ansible-Role/nebula_cert_renewal.yml
Stefan Mewes 53c9eba7d2 Skript Cert Renewal
2026-04-12 22:11:55 +02:00

387 lines
14 KiB
YAML
Raw Blame History

---
# =============================================================================
# Nebula Certificate Renewal Playbook
# =============================================================================
#
# Dieses Playbook erneuert abgelaufene (oder bald ablaufende) Nebula-Zertifikate.
# Es funktioniert auch für Nodes, die NUR über die Nebula-IP erreichbar sind.
#
# STRATEGIE für Remote-Only-Nodes:
# Ansible erreicht remote-only Nodes über die Nebula-IP. Das bedeutet: Nebula
# muss während des Rollouts LAUFEN bleiben. Das neue Zertifikat wird auf dem
# Lighthouse signiert, dann auf den Node kopiert und erst dann per Hot-Reload
# aktiviert (SIGHUP statt Neustart). So bleibt die Verbindung während des
# gesamten Vorgangs stabil.
#
# ABLAUF:
# 1. Prüfen welche Certs ablaufen (innerhalb von nebula_cert_renew_threshold_days)
# 2. Alte Certs auf dem Lighthouse sichern
# 3. Neue Certs auf dem Lighthouse signieren
# 4. Neue Certs auf die Nodes kopieren
# 5. Nebula per SIGHUP neu laden (kein Verbindungsabbruch)
#
# VERWENDUNG:
#
# Alle Nodes prüfen und bei Bedarf erneuern:
# ansible-playbook -i inventory nebula_cert_renew.yml
#
# Nur bestimmte Nodes erneuern:
# ansible-playbook -i inventory nebula_cert_renew.yml --limit web01,db01
#
# Alle Certs erzwungen erneuern (egal ob abgelaufen oder nicht):
# ansible-playbook -i inventory nebula_cert_renew.yml -e nebula_cert_force_renew=true
#
# Schwellwert anpassen (Standard: 30 Tage vor Ablauf):
# ansible-playbook -i inventory nebula_cert_renew.yml -e nebula_cert_renew_threshold_days=60
#
# VARIABLEN (können in group_vars oder per -e übergeben werden):
# nebula_cert_renew_threshold_days: 30 # Erneuerung X Tage vor Ablauf
# nebula_cert_force_renew: false # true = immer erneuern
# nebula_client_cert_duration: "43800h0m0s" # Laufzeit der neuen Certs (5 Jahre)
# nebula_network_cidr: 24
#
# INVENTORY-VORAUSSETZUNGEN:
# - Gruppe [nebula_lighthouse] muss existieren
# - groups['nebula_lighthouse'][0] ist der Primary Lighthouse (CA-Schlüssel)
# - Nodes haben nebula_internal_ip_addr gesetzt
# - Remote-only Nodes: ansible_host auf die Nebula-IP setzen
#
# BEISPIEL INVENTORY:
# [nebula_lighthouse]
# lighthouse01.example.com nebula_internal_ip_addr=10.43.0.1
#
# [servers]
# web01.example.com nebula_internal_ip_addr=10.43.0.2
# # Nur über Nebula erreichbar - ansible_host auf Nebula-IP:
# remote01 ansible_host=10.43.0.5 nebula_internal_ip_addr=10.43.0.5
#
# =============================================================================
# -----------------------------------------------------------------------------
# PHASE 1: Zertifikate prüfen und ggf. auf dem Lighthouse neu signieren
# Läuft auf dem Primary Lighthouse (er besitzt den CA-Key)
# -----------------------------------------------------------------------------
- name: "Nebula Cert Renewal - Phase 1: Prüfen & Signieren auf Primary Lighthouse"
hosts: "{{ groups['nebula_lighthouse'][0] }}"
gather_facts: false
become: true
vars:
nebula_cert_renew_threshold_days: 30
nebula_cert_force_renew: false
nebula_client_cert_duration: "43800h0m0s"
nebula_network_cidr: 24
nebula_cert_dir: /opt/nebula
# Alle Nodes aus dem Inventory ermitteln (Lighthouse selbst + alle anderen)
_all_nebula_nodes: >-
{{
(groups['nebula_lighthouse'] + groups.get('servers', []) + groups.get('nebula_nodes', []))
| unique
}}
tasks:
- name: Sicherstellen dass python3-dateutil installiert ist (für Datumsvergleich)
package:
name: python3-dateutil
state: present
ignore_errors: true
- name: Zertifikats-Ablaufdaten für alle Nodes ermitteln
command: >
{{ nebula_cert_dir }}/nebula-cert print -json
-path {{ nebula_cert_dir }}/{{ item }}.crt
register: _cert_info_raw
loop: "{{ _all_nebula_nodes }}"
changed_when: false
ignore_errors: true
# Fehler ignorieren falls Cert noch nicht existiert
- name: Ablaufstatus pro Node berechnen
set_fact:
_cert_status: >-
{{
_cert_status | default({}) | combine({
item.item: {
'exists': item.rc == 0,
'expired_or_missing': (item.rc != 0) or (
(item.stdout | from_json).details.notAfter
| int < (ansible_date_time.epoch | int + nebula_cert_renew_threshold_days * 86400)
),
'not_after': (item.rc == 0) | ternary(
(item.stdout | from_json).details.notAfter | int | strftime('%Y-%m-%d'),
'N/A'
)
}
})
}}
loop: "{{ _cert_info_raw.results }}"
loop_control:
label: "{{ item.item }}"
vars:
ansible_date_time:
epoch: "{{ lookup('pipe', 'date +%s') }}"
- name: Status-Übersicht anzeigen
debug:
msg: >-
{{ item.key }}:
Ablauf={{ _cert_status[item.key].not_after }},
Erneuerung nötig={{ _cert_status[item.key].expired_or_missing or nebula_cert_force_renew | bool }}
loop: "{{ _cert_status | dict2items }}"
loop_control:
label: "{{ item.key }}"
- name: Backup-Verzeichnis anlegen
file:
path: "{{ nebula_cert_dir }}/cert_backup_{{ lookup('pipe', 'date +%Y%m%d_%H%M%S') }}"
state: directory
owner: root
group: root
mode: '0700'
register: _backup_dir
- name: Backup der bestehenden Certs erstellen
copy:
src: "{{ nebula_cert_dir }}/{{ item }}.crt"
dest: "{{ _backup_dir.path }}/{{ item }}.crt"
remote_src: true
owner: root
group: root
mode: '0600'
loop: "{{ _all_nebula_nodes }}"
when: _cert_status[item].exists
ignore_errors: true
- name: Ablaufende/fehlende Certs auf Lighthouse löschen (damit nebula-cert neu signiert)
file:
path: "{{ nebula_cert_dir }}/{{ item }}"
state: absent
loop: >-
{{
_cert_status | dict2items
| selectattr('value.expired_or_missing', 'equalto', true)
| map(attribute='key')
| product(['.crt', '.key'])
| map('join')
| list
}}
when: nebula_cert_force_renew | bool or _cert_status[item.split('.crt')[0].split('.key')[0]].expired_or_missing
# Lighthouse-eigenes Cert separat behandelt (unten)
- name: Neue Certs für Lighthouse selbst signieren (falls nötig)
command: >
{{ nebula_cert_dir }}/nebula-cert sign
-name "{{ item }}"
-ip "{{ hostvars[item].nebula_internal_ip_addr }}/{{ nebula_network_cidr }}"
-duration "{{ nebula_client_cert_duration }}"
args:
chdir: "{{ nebula_cert_dir }}"
creates: "{{ nebula_cert_dir }}/{{ item }}.crt"
loop: "{{ groups['nebula_lighthouse'] }}"
when: >
nebula_cert_force_renew | bool or
(_cert_status[item].expired_or_missing | default(true))
- name: Neue Certs für alle anderen Nodes signieren (falls nötig)
command: >
{{ nebula_cert_dir }}/nebula-cert sign
-name "{{ item }}"
-ip "{{ hostvars[item].nebula_internal_ip_addr }}/{{ nebula_network_cidr }}"
-duration "{{ nebula_client_cert_duration }}"
args:
chdir: "{{ nebula_cert_dir }}"
creates: "{{ nebula_cert_dir }}/{{ item }}.crt"
loop: >-
{{
_all_nebula_nodes
| difference(groups['nebula_lighthouse'])
}}
when: >
nebula_cert_force_renew | bool or
(_cert_status[item].expired_or_missing | default(true))
- name: Neue Ablaufdaten zur Bestätigung anzeigen
command: >
{{ nebula_cert_dir }}/nebula-cert print -json
-path {{ nebula_cert_dir }}/{{ item }}.crt
register: _new_cert_info
loop: "{{ _all_nebula_nodes }}"
changed_when: false
ignore_errors: true
- name: Neue Cert-Laufzeiten anzeigen
debug:
msg: >-
{{ item.item }}:
gültig bis {{ (item.stdout | from_json).details.notAfter | int | strftime('%Y-%m-%d %H:%M') }}
loop: "{{ _new_cert_info.results }}"
loop_control:
label: "{{ item.item }}"
when: item.rc == 0
# -----------------------------------------------------------------------------
# PHASE 2: Certs auf Lighthouse-Nodes selbst deployen
# Nebula auf dem Lighthouse neu laden (SIGHUP - kein Verbindungsabbruch!)
# -----------------------------------------------------------------------------
- name: "Nebula Cert Renewal - Phase 2: Certs auf Lighthouse deployen"
hosts: nebula_lighthouse
gather_facts: false
become: true
serial: 1 # Lighthouses nacheinander - immer einer aktiv
vars:
nebula_cert_dir: /opt/nebula
nebula_cert_renew_threshold_days: 30
nebula_cert_force_renew: false
tasks:
- name: Cert-Dateien vom Primary Lighthouse einlesen
slurp:
src: "{{ nebula_cert_dir }}/{{ item }}"
register: _lh_cert_files
delegate_to: "{{ groups['nebula_lighthouse'][0] }}"
loop:
- "{{ inventory_hostname }}.crt"
- "{{ inventory_hostname }}.key"
- ca.crt
- name: Neue Cert/Key/CA auf Lighthouse-Node schreiben
copy:
dest: "{{ nebula_cert_dir }}/{{ item.item }}"
content: "{{ item.content | b64decode }}"
owner: root
group: root
mode: '0600'
loop: "{{ _lh_cert_files.results }}"
loop_control:
label: "{{ item.item }}"
register: _lh_cert_written
notify: nebula lighthouse hot-reload
# WICHTIG: SIGHUP statt Neustart - Nebula lädt Certs ohne Verbindungsabbruch
handlers:
- name: nebula lighthouse hot-reload
command: pkill -HUP -f "nebula.*config.yml"
# Alternativ falls systemd verwendet wird:
# systemd: name=lighthouse state=reloaded
# Nebula reagiert auf SIGHUP mit Reload der Certs seit v1.6+
ignore_errors: true
# -----------------------------------------------------------------------------
# PHASE 3: Certs auf alle regulären Nodes deployen
# Remote-only Nodes: Verbindung über Nebula-IP bleibt durch SIGHUP-Strategie stabil
# -----------------------------------------------------------------------------
- name: "Nebula Cert Renewal - Phase 3: Certs auf Nodes deployen"
hosts: "{{ groups.get('servers', []) + groups.get('nebula_nodes', []) | unique }}"
gather_facts: false
become: true
serial: 5 # 5 Nodes gleichzeitig - anpassen nach Bedarf
vars:
nebula_cert_dir: /opt/nebula
nebula_cert_renew_threshold_days: 30
nebula_cert_force_renew: false
tasks:
- name: Prüfen ob dieser Node ein Cert-Renewal benötigt
command: >
{{ nebula_cert_dir }}/nebula-cert print -json
-path {{ nebula_cert_dir }}/{{ inventory_hostname }}.crt
register: _local_cert_check
changed_when: false
ignore_errors: true
delegate_to: "{{ groups['nebula_lighthouse'][0] }}"
# Wir prüfen auf dem Lighthouse, nicht lokal - der hat das neue Cert
- name: Cert-Erneuerung überspringen (kein Renewal nötig)
meta: end_host
when: >
not (nebula_cert_force_renew | bool) and
_local_cert_check.rc == 0 and
((_local_cert_check.stdout | from_json).details.notAfter | int) >
(lookup('pipe', 'date +%s') | int + nebula_cert_renew_threshold_days * 86400)
# Cert-Dateien vom Primary Lighthouse per slurp holen (in-memory, kein temp-file)
- name: Cert-Dateien vom Primary Lighthouse einlesen
slurp:
src: "{{ nebula_cert_dir }}/{{ item }}"
register: _node_cert_files
delegate_to: "{{ groups['nebula_lighthouse'][0] }}"
loop:
- "{{ inventory_hostname }}.crt"
- "{{ inventory_hostname }}.key"
- ca.crt
- name: Neue Cert/Key/CA auf Node schreiben
copy:
dest: "{{ nebula_cert_dir }}/{{ item.item }}"
content: "{{ item.content | b64decode }}"
owner: root
group: root
mode: '0600'
loop: "{{ _node_cert_files.results }}"
loop_control:
label: "{{ item.item }}"
register: _node_cert_written
notify: nebula node hot-reload
# SIGHUP: Nebula lädt das neue Cert ohne die bestehende Tunnel-Verbindung zu trennen.
# Das ist der entscheidende Trick für remote-only Nodes:
# Die SSH-Verbindung über Nebula bleibt aktiv während das Cert neu geladen wird.
handlers:
- name: nebula node hot-reload
command: pkill -HUP -f "nebula.*config.yml"
# Alternativ:
# systemd: name=nebula state=reloaded
ignore_errors: true
# -----------------------------------------------------------------------------
# PHASE 4: Abschlussbericht
# -----------------------------------------------------------------------------
- name: "Nebula Cert Renewal - Phase 4: Abschlussbericht"
hosts: "{{ groups['nebula_lighthouse'][0] }}"
gather_facts: false
become: true
vars:
nebula_cert_dir: /opt/nebula
_all_nebula_nodes: >-
{{
(groups['nebula_lighthouse'] + groups.get('servers', []) + groups.get('nebula_nodes', []))
| unique
}}
tasks:
- name: Finale Cert-Ablaufdaten ermitteln
command: >
{{ nebula_cert_dir }}/nebula-cert print -json
-path {{ nebula_cert_dir }}/{{ item }}.crt
register: _final_cert_info
loop: "{{ _all_nebula_nodes }}"
changed_when: false
ignore_errors: true
- name: Abschlussbericht
debug:
msg: >-
{{ item.item | ljust(40) }}
gültig bis: {{ (item.stdout | from_json).details.notAfter | int | strftime('%Y-%m-%d') }}
loop: "{{ _final_cert_info.results }}"
loop_control:
label: "{{ item.item }}"
when: item.rc == 0
- name: Nodes mit Fehler (Cert nicht lesbar)
debug:
msg: "WARNUNG: Cert für {{ item.item }} konnte nicht gelesen werden!"
loop: "{{ _final_cert_info.results }}"
loop_control:
label: "{{ item.item }}"
when: item.rc != 0
Reference in New Issue View Git Blame Copy Permalink