martes, 12 de agosto de 2025

script Post Leapp

 #!/bin/ksh


LOGFILE="/var/log/postleap_firewalld_check.log"

DATE=$(date "+%Y-%m-%d %H:%M:%S")


echo "[$DATE] --- Inicio del chequeo post-Leapp FirewallD ---" | tee -a $LOGFILE


# 1. Verificar si firewalld está activo

if systemctl is-active --quiet firewalld; then

    echo "✅ firewalld está activo." | tee -a $LOGFILE

else

    echo "⚠️  firewalld está inactivo. Se recomienda activarlo si se requiere protección a nivel red." | tee -a $LOGFILE

    read -p "¿Deseás activarlo ahora? (s/n): " ACTIVATE_FW

    if [[ "$ACTIVATE_FW" == "s" ]]; then

        systemctl enable --now firewalld

        echo "🔥 firewalld activado." | tee -a $LOGFILE

    else

        echo "⚠️  Se continúa con firewalld desactivado." | tee -a $LOGFILE

        exit 0

    fi

fi


# 2. Obtener puertos en uso por procesos (TCP y UDP)

echo "\n🔍 Buscando puertos en escucha por procesos..." | tee -a $LOGFILE

LISTEN_PORTS=$(ss -tuln | awk '/LISTEN|UNCONN/ && $5 ~ /[0-9]+$/ {split($5,a,":"); print a[length(a)]"/"$1}' | sort -u)


# 3. Obtener puertos y servicios habilitados por firewalld (zona default)

DEFAULT_ZONE=$(firewall-cmd --get-default-zone)

OPEN_PORTS=$(firewall-cmd --zone=$DEFAULT_ZONE --list-ports)

OPEN_SERVICES=$(firewall-cmd --zone=$DEFAULT_ZONE --list-services)


# 4. Comparar puertos en uso vs habilitados (incluye servicios)

echo "\n📊 Comparando puertos en uso vs habilitados en firewalld..." | tee -a $LOGFILE

PORTS_TO_ADD=""


for PORT_PROTO in $LISTEN_PORTS; do

    PORT_NUM=$(echo "$PORT_PROTO" | cut -d'/' -f1)

    PROTO=$(echo "$PORT_PROTO" | cut -d'/' -f2 | tr 'A-Z' 'a-z')


    # Chequear si el puerto está habilitado explícitamente

    echo "$OPEN_PORTS" | grep -qw "${PORT_NUM}/${PROTO}"

    if [[ $? -eq 0 ]]; then

        continue

    fi


    # Chequear si el puerto está cubierto por un servicio

    SERVICE_MATCH=0

    for SVC in $OPEN_SERVICES; do

        PORTS_SVC=$(firewall-cmd --info-service=$SVC | grep ports: | awk '{print $2}')

        echo "$PORTS_SVC" | grep -qw "${PORT_NUM}/${PROTO}" && SERVICE_MATCH=1

    done


    if [[ $SERVICE_MATCH -eq 0 ]]; then

        echo "⚠️  Puerto $PORT_NUM/$PROTO está en uso pero NO habilitado en firewalld." | tee -a $LOGFILE

        PORTS_TO_ADD="$PORTS_TO_ADD ${PORT_NUM}/${PROTO}"

    fi

done


# 5. Ofrecer agregar automáticamente los puertos detectados

if [[ -n "$PORTS_TO_ADD" ]]; then

    echo "\n🛡️  Los siguientes puertos están en uso pero no habilitados: $PORTS_TO_ADD" | tee -a $LOGFILE

    read -p "¿Querés habilitarlos automáticamente en firewalld? (s/n): " ADD_PORTS

    if [[ "$ADD_PORTS" == "s" ]]; then

        for P in $PORTS_TO_ADD; do

            firewall-cmd --zone=$DEFAULT_ZONE --permanent --add-port=$P

            echo "✅ Puerto $P habilitado." | tee -a $LOGFILE

        done

        firewall-cmd --reload

        echo "🔄 firewalld recargado con los nuevos puertos." | tee -a $LOGFILE

    else

        echo "📝 No se agregaron los puertos. Revisalos manualmente." | tee -a $LOGFILE

    fi

else

    echo "✅ Todos los puertos en uso están habilitados en firewalld o cubiertos por un servicio." | tee -a $LOGFILE

fi


# 6. Chequear servicios en estado failed

echo "\n🔍 Verificando servicios en estado FAILED..." | tee -a $LOGFILE

FAILED_SERVICES=$(systemctl -l -t service --state=failed | grep -v "0 loaded units" | grep -v "LOAD" | grep -v "UNIT")

if [[ -n "$FAILED_SERVICES" ]]; then

    echo "⚠️  Servicios en estado failed detectados:" | tee -a $LOGFILE

    echo "$FAILED_SERVICES" | tee -a $LOGFILE

else

    echo "✅ No hay servicios en estado failed." | tee -a $LOGFILE

fi


# 7. Chequear variables NEXUS

echo "\n🔍 Verificando variables de entorno NEXUS_*..." | tee -a $LOGFILE

NEXUS_VARS=$(env | grep -i ^NEXUS_)


if [[ -n "$NEXUS_VARS" ]]; then

    echo "✅ Variables NEXUS detectadas:" | tee -a $LOGFILE

    echo "$NEXUS_VARS" | tee -a $LOGFILE

else

    echo "⚠️  No se encontraron variables NEXUS_* en el entorno." | tee -a $LOGFILE

fi


echo "✅ Revisión finalizada. Verificá el log: $LOGFILE"


viernes, 8 de agosto de 2025

auditoria puntual por hora

 ---

- name: Auditoría forense con CSV consolidado y legible

  hosts: all

  gather_facts: false


  vars:

    fecha_inicio: "2025-08-01 21:00:00"

    fecha_fin: "2025-08-02 02:30:00"


  tasks:

    - name: Obtener hostname

      command: hostname

      register: hostname


    - name: Obtener historial de root

      shell: |

        cat /root/.bash_history 2>/dev/null | grep -Ei 'rm|unlink|mv|truncate'

      register: root_history

      ignore_errors: true


    - name: Obtener historial de ansible

      shell: |

        cat /home/ansible/.bash_history 2>/dev/null | grep -Ei 'rm|unlink|mv|truncate'

      register: ansible_history

      ignore_errors: true


    - name: Buscar uso de sudo por ansible en ventana temporal

      shell: |

        awk '

          BEGIN {

            start = mktime("2025 08 01 21 00 00")

            end = mktime("2025 08 02 02 30 00")

          }

          {

            cmd = "date -d \""$1" "$2" "$3" "$4"\" +%s"

            cmd | getline t

            close(cmd)

            if (t >= start && t <= end) print $0

          }

        ' /var/log/secure | grep 'sudo'

      register: sudo_usage

      ignore_errors: true


    - name: Verificar si auditd está instalado

      shell: rpm -q audit

      register: auditd_installed

      ignore_errors: true


    - name: Buscar comandos sospechosos con auditd

      when: auditd_installed.rc == 0

      shell: |

        ausearch -x rm -x unlink -x rmdir -ts "{{ fecha_inicio }}" -te "{{ fecha_fin }}"

      register: audit_logs

      ignore_errors: true


    - name: Preparar línea CSV por host (con campos entre comillas dobles)

      set_fact:

        audit_line: |

          "{{ hostname.stdout }}","{{ root_history.stdout | default('') | replace('\n', ' | ') }}","{{ ansible_history.stdout | default('') | replace('\n', ' | ') }}","{{ sudo_usage.stdout | default('') | replace('\n', ' | ') }}","{{ audit_logs.stdout | default('') | replace('\n', ' | ') }}"


    - name: Agregar cabecera si no existe (solo una vez)

      local_action:

        module: lineinfile

        path: ./auditoria_resultados.csv

        line: '"Hostname","Root History","Ansible History","Sudo Usage","Auditd Events"'

        create: yes

        insertafter: BOF

      delegate_to: localhost

      run_once: true


    - name: Agregar línea por host al CSV

      local_action:

        module: lineinfile

        path: ./auditoria_resultados.csv

        line: "{{ audit_line }}"

        create: yes

        insertafter: EOF

      delegate_to: localhost


viernes, 11 de julio de 2025

Check List , instalacion y configuracion cluster PaceMaker con SAP netweaver en Vmware

 # ✅ Checklist - SAP NetWeaver HA Cluster en RHEL 8.10 con NFS + VMware


## 🖥️ Etapa 0 - Preparativos en vCenter

### 👤 Usuario de vCenter para STONITH (fence_vmware_soap)

- [ ] Crear un usuario dedicado en vCenter (ej: `svc-cluster-fence`)
- [ ] Asignar permisos mínimos requeridos sobre las VMs del clúster:

  | Permiso vCenter                     | Requerido |
  |-------------------------------------|-----------|
  | `VirtualMachine.Interact.PowerOff` | ✅        |
  | `VirtualMachine.Interact.PowerOn`  | ✅        |
  | `VirtualMachine.Config.Query`      | ✅        |
  | `VirtualMachine.Config.Settings`   | ✅        |
  | `VirtualMachine.Inventory`         | ✅        |
  | `System.Read`                      | ✅        |

- [ ] Asignar rol personalizado o usar el rol "Virtual Machine User"
- [ ] Aplicar los permisos al nivel de Datacenter, carpeta o VMs

### ⚙️ Reglas y ajustes de DRS/HA

- [ ] Crear regla de anti-afinidad entre nodos del clúster (ASCS y ERS)
- [ ] Deshabilitar DRS automático para las VMs del clúster (recomendado:
manual o parcialmente automatizado)
- [ ] Deshabilitar snapshot o backup con freeze en VMs SAP productivas

---

## 🧾 Etapa 1 - Requisitos previos y sistema base

- [ ] Verificar que ambas VMs estén creadas y con recursos suficientes
(RAM, CPU, disco)  # ambos
- [ ] Establecer IP fija y hostname FQDN en cada nodo  # ambos
- [ ] Validar conectividad entre nodos (`ping`, `ssh`, resolución DNS)  # ambos
- [ ] Configurar NTP o `chronyd` sincronizado  # ambos
- [ ] Registrar ambos nodos a Red Hat Subscription Manager  # ambos
  ```bash
  subscription-manager register
  subscription-manager attach --auto
  ```

---

## 📦 Etapa 2 - Habilitar repositorios y paquetes necesarios

- [ ] Habilitar los repos oficiales  # ambos
  ```bash
  subscription-manager repos --enable=rhel-8-for-x86_64-baseos-rpms \
                             --enable=rhel-8-for-x86_64-appstream-rpms \
                             --enable=rhel-8-for-x86_64-sap-netweaver-rpms \
                             --enable=rhel-8-for-x86_64-sap-solutions-rpms \
                             --enable=rhel-8-for-x86_64-highavailability-rpms
  ```

- [ ] Instalar paquetes base  # ambos
  ```bash
  dnf install -y pcs pacemaker fence-agents-all \
    resource-agents-sap resource-agents-sap-hana \
    tuned-profiles-sap sap-cluster-connector
  ```

---

## 🔐 Etapa 3 - Configurar usuario hacluster y PCS

- [ ] Verificar que el usuario `hacluster` fue creado automáticamente por la
instalación del paquete `pcs`  # ambos
- [ ] Establecer contraseña al usuario `hacluster`  # ambos
  ```bash
  passwd hacluster
  ```

- [ ] Habilitar e iniciar `pcsd`  # ambos
  ```bash
  systemctl enable --now pcsd
  ```

- [ ] Autenticar ambos nodos con `pcs`  # nodo1
  ```bash
  pcs cluster auth nodo1 nodo2 -u hacluster -p TU_CLAVE
  ```

---

## ⚙️ Etapa 4 - Crear y arrancar clúster básico

- [ ] Crear el clúster  # nodo1
  ```bash
  pcs cluster setup --name sap_ha_cluster nodo1 nodo2
  pcs cluster start --all
  pcs cluster enable --all
  ```

- [ ] Deshabilitar quorum sólo si estás en pruebas  # nodo1
  ```bash
  pcs property set no-quorum-policy=freeze
  ```

---

## 🔌 Etapa 5 - Configurar STONITH con VMware

- [ ] Instalar agentes si faltan  # ambos
  ```bash
  dnf install -y fence-agents-vmware
  ```

- [ ] Crear recurso STONITH para cada nodo  # nodo1
  ```bash
  pcs stonith create fence_vm1 fence_vmware_soap \
    ip="vcenter.example.com" login="user" passwd="pass" \
    ssl=1 port="VM-NAME" pcmk_host_list="nodo1"

  pcs stonith create fence_vm2 fence_vmware_soap \
    ip="vcenter.example.com" login="user" passwd="pass" \
    ssl=1 port="VM-NAME" pcmk_host_list="nodo2"
  ```

---

## 📁 Etapa 6 - Recursos compartidos por NFS

- [ ] Validar que el servidor NFS esté en HA (recomendado)  # N/A
- [ ] Verificar que los directorios como
`/sapmnt`, `/usr/sap/trans` estén exportados  # ambos
- [ ] Crear recursos NFS  # nodo1
  ```bash
  pcs resource create sapmnt Filesystem \
    device="nfs-server:/export/sapmnt" \
    directory="/sapmnt" fstype=nfs4 \
    options="hard,intr,nfsvers=4.1,_netdev" \
    op monitor interval=30s timeout=60s
  ```

---

## 🧠 Etapa 7 - Recursos SAPInstance

- [ ] Crear recurso ASCS  # nodo1
  ```bash
  pcs resource create sap_ascs SAPInstance \
    InstanceName=SAP_ASCS00_<SID> \
    StartProfile="/usr/sap/<SID>/SYS/profile/START_ASCS00_<HOST>" \
    AUTOMATIC_RECOVER=false \
    op monitor interval=60s timeout=60s on-fail=restart
  ```

- [ ] Crear recurso ERS  # nodo1
  ```bash
  pcs resource create sap_ers SAPInstance \
    InstanceName=SAP_ERS10_<SID> \
    StartProfile="/usr/sap/<SID>/SYS/profile/START_ERS10_<HOST>" \
    AUTOMATIC_RECOVER=false \
    op monitor interval=60s timeout=60s on-fail=restart
  ```

---

## 🔄 Etapa 8 - Agrupamiento, orden y colocación

- [ ] Crear grupo de recursos  # nodo1
  ```bash
  pcs resource group add sap_group sapmnt sap_ascs
  ```

- [ ] Colocar ERS separado de ASCS  # nodo1
  ```bash
  pcs constraint colocation add sap_ers with sap_ascs -inf: same-node=false
  ```

- [ ] Preferencias de ubicación  # nodo1
  ```bash
  pcs constraint location sap_ascs prefers nodo1=50
  pcs constraint location sap_ers prefers nodo2=50
  ```

---

## 🧪 Etapa 9 - Validación

- [ ] Verificar estado general  # cualquier nodo
  ```bash
  pcs status
  crm_mon -1
  ```

- [ ] Probar failover  # nodo1
  ```bash
  pcs resource move sap_ascs nodo2
  pcs resource clear sap_ascs
  ```

- [ ] Validar logs: `/var/log/pacemaker.log`, `/var/log/messages`,
y SAP `/usr/sap/<SID>/ASCS00/work/dev_*`  # ambos

---

## 🧷 Extras opcionales

- [ ] Aplicar profile de tuning para SAP  # ambos
  ```bash
  tuned-adm profile sap-netweaver
  ```

- [ ] Documentar todos los pasos y respaldar configuración  # nodo1
  ```bash
  pcs config show > cluster-config-backup.txt
  ```
Notas importante :
El recurso SAP_ERS (Enqueue Replication Server) es fundamental en entornos SAP HA,
especialmente para proteger la cola de bloqueo (Enqueue Server) y asegurar que el
sistema pueda conmutar sin pérdida de locks críticos.

✅ Qué debes configurar en el recurso SAP_ERS

📌 Prerrequisitos

  1. El software SAP (ERS) debe estar instalado en ambos nodos.

  2. El ERS se ejecuta como un instance number, típicamente algo como ERS## (ej. ERS20).

  3. El usuario sapadm o el correspondiente de la SID debe existir.

  4. El clúster debe tener acceso completo al filesystem compartido, si aplica.

🧩 Recurso tipo: ocf:heartbeat:SAPInstance

El recurso SAP_ERS se configura con el mismo agente OCF que se usa para una

instancia SAP (SAPInstance), pero apuntando a la instancia de tipo ERS.

pcs resource create SAP_ERS ocf:heartbeat:SAPInstance \ SID=PRD \ InstanceName=ERS20_prdadm \ START_PROFILE="/usr/sap/PRD/SYS/profile/START_ERS20_hostanme" \ AUTOMATIC_RECOVER=false \ op monitor interval=60s timeout=60s \ op start timeout=600s \ op stop timeout=600s \ meta resource-stickiness=1000 \ meta priority=10 \ --group sap_ers_group

⚠️ Ajustá SID, InstanceName, START_PROFILE, y el group según tu entorno

Parametros explicados

Parámetro Descripción
SID=PRD El System ID de tu entorno SAP.
InstanceName=ERS20_prdadm ERS20 es el número de instancia, seguido del usuario del sistema SAP (prdadm).
START_PROFILE Ruta al perfil de arranque del ERS. Podés encontrarlo en /usr/sap/<SID>/SYS/profile/.
AUTOMATIC_RECOVER=false Es importante dejar esto en false en ERS.
monitor, start, stop Opciones de tiempo de espera (modificables según tus tiempos).
resource-stickiness Qué tanto se "pega" el recurso al nodo actual.
priority=10 Ayuda al cluster a decidir prioridades en failovers.
--group (Opcional) lo podés incluir dentro de un grupo si lo vas a manejar junto a otros recursos como IP virtual, file system, etc.