Jekyll2025-05-28T15:51:15+00:00https://lorcopotia.github.io/feed.xmlIT neighborDevOps Engineer, SysAdmin, Gamer y filósofo de la vida.Aprende Python creando tu propio contador de palabras2025-05-04T00:00:00+00:002025-05-04T00:00:00+00:00https://lorcopotia.github.io/2025/05/04/Aprende-Python-creando-tu-propio-contador-de-palabrasUna de las mejores formas de iniciarte en el mundo del desarrollo con Python es mediante la creación de scripts prácticos y reutilizables. Hoy vamos a explorar un ejemplo sencillo pero poderoso: un contador de palabras que analiza archivos de texto.

Este script no solo enseña los fundamentos de Python, sino que también introduce buenas prácticas como uso de módulos estándar, expresiones regulares y estructuras de control.

🔍 ¿Qué hace el script?

El objetivo del script es leer un archivo de texto, contar la frecuencia de cada palabra (ignorando mayúsculas, minúsculas y símbolos especiales), y mostrar los resultados ordenados por frecuencia de uso.

🧱 Paso a paso

import os
from collections import Counter
import re
  • os: para verificar si el archivo existe.
  • Counter: estructura que cuenta elementos rápidamente.
  • re: expresiones regulares para limpiar y extraer palabras.

💬 Función principal

def count_words(filename):
    with open(filename, 'r', encoding='utf-8') as file:
        words = []
        for line in file:
            line_words = re.findall(r'\b\w+\b', line.lower())
            words.extend(line_words)
        word_count = Counter(words)
        for word, count in word_count.most_common():
            print(f"{word}: {count}")
  • Lee el archivo línea por línea.
  • Convierte todo a minúsculas.
  • Usa una expresión regular para encontrar solo palabras.
  • Usa Counter para contar cuántas veces aparece cada palabra.
  • Muestra los resultados ordenados por frecuencia.

🚀 Bloque principal

if __name__ == "__main__":
    filename = 'lewis.txt'
    if os.path.exists(filename):
        count_words(filename)
    else:
        print(f"File '{filename}' does not exist.")

🌟 ¿Por qué es útil para principiantes?

  • Te obliga a pensar en flujos de entrada/salida.
  • Introduce el manejo de errores de forma simple (os.path.exists).
  • Trabaja con archivos de texto, una tarea común en cualquier ámbito.
  • Te enseña a usar herramientas potentes como Counter y re.

🧠 Conclusión

Este tipo de script es ideal para quienes empiezan con Python porque combina varios conceptos esenciales en menos de 30 líneas de código. Además, ¡puedes adaptarlo fácilmente para otros fines como análisis de logs, procesamiento de datos o creación de herramientas de línea de comandos!

¿Y tú, qué vas a automatizar hoy? 💡

]]>Problemas con disco SSD en puerto USB3 de mi Raspberry pi 4B2024-12-26T00:00:00+00:002024-12-26T00:00:00+00:00https://lorcopotia.github.io/2024/12/26/Problemas-con-Raspberry-pi-usb-ssdRecientemente por navidad me regale un SSD de 1TB para almacenar mis datos, videos y demás ya que estaba en oferta.

Tengo un raspberry pi 4B que utilizo para mis proyectos personales. En el tengo desplegados los siguientes servicios:

  • Pihole
  • Samba
  • Jellyfin
  • Plex
  • Jackett
  • Sonarr
  • Radarr
  • Transmission-openvpn
  • Overseerr
  • Twingate
  • Homepage
  • Portainer

Luego de conectar el SSD utilizando una carcasa que compré también en oferta, después de 12h aprox la raspberry pi dejo de reconocer el dispositivo mostrandome los siguientes mensajes en dmesg:

[  105.485849] xhci_hcd 0000:01:00.0: WARNING: Host System Error
[  110.559295] xhci_hcd 0000:01:00.0: xHCI host not responding to stop endpoint command
[  110.559312] xhci_hcd 0000:01:00.0: xHCI host controller not responding, assume dead
[  110.559357] xhci_hcd 0000:01:00.0: HC died; cleaning up
[  110.559437] sd 0:0:0:0: [sda] tag#10 uas_eh_abort_handler 0 uas-tag 1 inflight: CMD
[  110.559445] sd 0:0:0:0: [sda] tag#10 CDB: opcode=0x28 28 00 05 80 08 48 00 00 10 00
[  110.559451] sd 0:0:0:0: [sda] tag#9 uas_eh_abort_handler 0 uas-tag 22 inflight: CMD
[  110.559455] sd 0:0:0:0: [sda] tag#9 CDB: opcode=0x28 28 00 05 80 08 20 00 00 10 00
[  110.559460] sd 0:0:0:0: [sda] tag#8 uas_eh_abort_handler 0 uas-tag 21 inflight: CMD
[  110.559464] sd 0:0:0:0: [sda] tag#8 CDB: opcode=0x28 28 00 05 80 08 00 00 00 08 00
[  110.559469] sd 0:0:0:0: [sda] tag#7 uas_eh_abort_handler 0 uas-tag 4 inflight: CMD
[  110.559473] sd 0:0:0:0: [sda] tag#7 CDB: opcode=0x28 28 00 05 40 08 58 00 00 10 00
[  110.559478] sd 0:0:0:0: [sda] tag#6 uas_eh_abort_handler 0 uas-tag 20 inflight: CMD
[  110.559482] sd 0:0:0:0: [sda] tag#6 CDB: opcode=0x28 28 00 05 40 08 30 00 00 18 00
[  110.559487] sd 0:0:0:0: [sda] tag#5 uas_eh_abort_handler 0 uas-tag 19 inflight: CMD
[  110.559490] sd 0:0:0:0: [sda] tag#5 CDB: opcode=0x28 28 00 05 40 08 10 00 00 10 00
[  110.559495] sd 0:0:0:0: [sda] tag#4 uas_eh_abort_handler 0 uas-tag 18 inflight: CMD
[  110.559499] sd 0:0:0:0: [sda] tag#4 CDB: opcode=0x28 28 00 05 40 08 00 00 00 08 00
[  110.559504] sd 0:0:0:0: [sda] tag#3 uas_eh_abort_handler 0 uas-tag 17 inflight: CMD
[  110.559507] sd 0:0:0:0: [sda] tag#3 CDB: opcode=0x28 28 00 05 00 08 60 00 00 10 00
[  110.559512] sd 0:0:0:0: [sda] tag#2 uas_eh_abort_handler 0 uas-tag 16 inflight: CMD
[  110.559516] sd 0:0:0:0: [sda] tag#2 CDB: opcode=0x28 28 00 05 00 08 38 00 00 08 00
[  110.559521] sd 0:0:0:0: [sda] tag#1 uas_eh_abort_handler 0 uas-tag 15 inflight: CMD
[  110.559524] sd 0:0:0:0: [sda] tag#1 CDB: opcode=0x28 28 00 05 00 08 00 00 00 08 00
[  110.559529] sd 0:0:0:0: [sda] tag#0 uas_eh_abort_handler 0 uas-tag 14 inflight: CMD
[  110.559532] sd 0:0:0:0: [sda] tag#0 CDB: opcode=0x28 28 00 04 c0 08 68 00 00 10 00
[  110.559538] sd 0:0:0:0: [sda] tag#25 uas_eh_abort_handler 0 uas-tag 3 inflight: CMD
[  110.559541] sd 0:0:0:0: [sda] tag#25 CDB: opcode=0x28 28 00 74 70 6d 00 00 00 08 00
[  110.559559] usb 1-1: USB disconnect, device number 2
[  110.560054] usb 2-2: USB disconnect, device number 2
[  110.560166] sd 0:0:0:0: [sda] tag#15 uas_zap_pending 0 uas-tag 5 inflight: CMD
[  110.560173] sd 0:0:0:0: [sda] tag#15 CDB: opcode=0x28 28 00 00 01 2c b0 00 00 08 00
[  110.560210] sd 0:0:0:0: [sda] tag#15 UNKNOWN(0x2003) Result: hostbyte=0x01 driverbyte=DRIVER_OK cmd_age=9s
[  110.560225] sd 0:0:0:0: [sda] tag#15 CDB: opcode=0x28 28 00 00 01 2c b0 00 00 08 00
[  110.560232] I/O error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.560274] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.560409] device offline error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.560970] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.561203] device offline error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.563398] device offline error, dev sda, sector 973342720 op 0x1:(WRITE) flags 0x9800 phys_seg 1 prio class 2
[  110.563450] Buffer I/O error on dev sda1, logical block 121667584, lost sync page write
[  110.563676] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm runc:[2:INIT]: reading directory lblock 0
[  110.564815] device offline error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.564905] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.565379] device offline error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.565555] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.565990] device offline error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.566173] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.566241] JBD2: I/O error when updating journal superblock for sda1-8.
[  110.566251] Aborting journal on device sda1-8.
[  110.566303] device offline error, dev sda, sector 76976 op 0x0:(READ) flags 0x3000 phys_seg 1 prio class 2
[  110.566323] device offline error, dev sda, sector 973342720 op 0x1:(WRITE) flags 0x9800 phys_seg 1 prio class 2
[  110.566330] device offline error, dev sda, sector 973342720 op 0x1:(WRITE) flags 0x9800 phys_seg 1 prio class 2
[  110.566335] Buffer I/O error on dev sda1, logical block 121667584, lost sync page write
[  110.566353] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.566386] JBD2: I/O error when updating journal superblock for sda1-8.
[  110.566447] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.566597] Buffer I/O error on dev sda1, logical block 0, lost sync page write
[  110.566609] EXT4-fs error (device sda1): __ext4_find_entry:1683: inode #2: comm dockerd: reading directory lblock 0
[  110.566629] EXT4-fs (sda1): shut down requested (2)
[  110.566684] EXT4-fs (sda1): I/O error while writing superblock
[  110.566726] Buffer I/O error on dev sda1, logical block 0, lost sync page write
[  110.566743] EXT4-fs (sda1): I/O error while writing superblock
[  110.579622] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579646] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579650] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579653] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579656] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579659] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579662] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579665] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579668] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579671] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579674] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579678] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579681] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579684] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579687] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579690] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579693] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579696] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579700] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579703] sd 0:0:0:0: Device offlined - not ready after error recovery
[  110.579738] sd 0:0:0:0: [sda] tag#25 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=32s
[  110.579748] sd 0:0:0:0: [sda] tag#25 CDB: opcode=0x28 28 00 74 70 6d 00 00 00 08 00
[  110.579793] sd 0:0:0:0: [sda] tag#0 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579798] sd 0:0:0:0: [sda] tag#0 CDB: opcode=0x28 28 00 04 c0 08 68 00 00 10 00
[  110.579815] sd 0:0:0:0: [sda] tag#1 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579819] sd 0:0:0:0: [sda] tag#1 CDB: opcode=0x28 28 00 05 00 08 00 00 00 08 00
[  110.579844] sd 0:0:0:0: [sda] tag#2 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579850] sd 0:0:0:0: [sda] tag#2 CDB: opcode=0x28 28 00 05 00 08 38 00 00 08 00
[  110.579862] sd 0:0:0:0: [sda] tag#3 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579859] Buffer I/O error on dev sda1, logical block 244190368, async page read
[  110.579866] sd 0:0:0:0: [sda] tag#3 CDB: opcode=0x28 28 00 05 00 08 60 00 00 10 00
[  110.579878] sd 0:0:0:0: [sda] tag#4 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579883] sd 0:0:0:0: [sda] tag#4 CDB: opcode=0x28 28 00 05 40 08 00 00 00 08 00
[  110.579893] sd 0:0:0:0: [sda] tag#5 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579898] sd 0:0:0:0: [sda] tag#5 CDB: opcode=0x28 28 00 05 40 08 10 00 00 10 00
[  110.579911] sd 0:0:0:0: [sda] tag#6 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579915] sd 0:0:0:0: [sda] tag#6 CDB: opcode=0x28 28 00 05 40 08 30 00 00 18 00
[  110.579933] sd 0:0:0:0: [sda] tag#7 UNKNOWN(0x2003) Result: hostbyte=0x07 driverbyte=DRIVER_OK cmd_age=36s
[  110.579937] sd 0:0:0:0: [sda] tag#7 CDB: opcode=0x28 28 00 05 40 08 58 00 00 10 00
[  110.627656] sd 0:0:0:0: [sda] Synchronizing SCSI cache
[  110.649895] sd 0:0:0:0: [sda] Synchronize Cache(10) failed: Result: hostbyte=0x07 driverbyte=DRIVER_OK
[  110.651240] scsi 0:0:0:0: rejecting I/O to dead device
[  110.651589] xhci_hcd 0000:01:00.0: WARN Can't disable streams for endpoint 0x82, streams are being disabled already
[  110.894702] EXT4-fs (sda1): unmounting filesystem 3f7d608d-0d52-4e00-a58b-12126dd6adc2.

Buscando en foros encontré el siguiente artículo que me proporcionó la solución:

# Añadir la siguiente línea al final del fichero /boot/firmware/config.txt
max_usb_current=1

Y después, reiniciar.

Espero que os sirva tanto como a mí. Feliz y próspero año nuevo a todos!!!

]]>Métodos de Gestión de Secretos en Ansible2024-12-11T00:00:00+00:002024-12-11T00:00:00+00:00https://lorcopotia.github.io/2024/12/11/M%C3%A9todos-de-gesti%C3%B3n-de-secretos-en-AnsibleMétodos de Gestión de Secretos en Ansible

Las fuentes describen principalmente un método para la gestión de secretos en Ansible: Ansible Vault. Ansible Vault funciona como una caja fuerte digital, permitiendo almacenar información sensible de manera segura. Este método implica los siguientes pasos:

  1. Cifrado del archivo: Se utiliza el comando ansible-vault encrypt para cifrar un archivo YAML que contiene las variables secretas. Ansible solicita una contraseña para cifrar el archivo.

  2. Almacenamiento de la clave: La contraseña utilizada para cifrar el archivo (la “clave” de la caja fuerte) se almacena de forma segura, separada del playbook.

  3. Descifrado durante la ejecución: Al ejecutar un playbook que utiliza variables cifradas con Vault, se usa la clave para descifrar el archivo en memoria, permitiendo a Ansible acceder a los datos.

Existen diferentes maneras de proporcionar la contraseña para descifrar el archivo:

  • Solicitar contraseña en tiempo de ejecución: Se puede usar la opción –ask-vault-pass al ejecutar el playbook para que Ansible solicite la contraseña al usuario.
  • Archivo de contraseñas: Se puede crear un archivo que contenga la contraseña y usar la opción –vault-password-file para indicarle a Ansible la ubicación del archivo. Este archivo debe tener permisos estrictos (600) para que solo el usuario pueda leerlo.
  • Script ejecutable: Similar al archivo de contraseñas, se puede usar un script que genere la contraseña como salida y pasar la ruta del script a Ansible.

Ventajas de Ansible Vault:

  • Seguridad: Ansible Vault utiliza cifrado AES-256, un algoritmo de cifrado robusto que hace que el descifrado sin la clave sea extremadamente difícil.
  • Integración: Vault está integrado en Ansible, simplificando su uso y evitando la necesidad de herramientas externas.
  • Flexibilidad: Vault puede cifrar diferentes tipos de archivos YAML, incluyendo archivos de variables, variables de host y grupo, e incluso archivos de tareas.

Alternativas a Ansible Vault:

Las fuentes también mencionan la posibilidad de usar servicios externos de gestión de secretos, como Vault de HashiCorp, Keywhiz de Square o servicios en la nube como AWS Key Management Service o Microsoft Azure Key Vault. Estos servicios ofrecen características más avanzadas que Ansible Vault, pero pueden ser más complejos de configurar.

Consideraciones de Seguridad:

  • La seguridad de Ansible Vault depende en gran medida de la seguridad de la contraseña utilizada para cifrar el archivo. Se recomienda utilizar contraseñas fuertes y almacenarlas de forma segura.
  • Si la clave se ve comprometida, la información cifrada con Vault se vuelve vulnerable. Es importante gestionar la rotación de claves y seguir buenas prácticas de seguridad.

Aunque Ansible Vault es una herramienta útil para proteger información sensible en playbooks de Ansible, es importante comprender sus limitaciones y aplicar las medidas de seguridad adecuadas para proteger las claves de cifrado.

]]>Creando Usuarios Con Ansible2024-11-27T00:00:00+00:002024-11-27T00:00:00+00:00https://lorcopotia.github.io/2024/11/27/Creando-usuarios-con-AnsibleProtegiendo las credenciales con Ansible Vault

¡Hola de nuevo, amantes de la automatización! ¿Listos para llevar nuestras habilidades con Ansible al siguiente nivel? En esta ocasión, vamos a aprender a crear usuarios en un servidor remoto de forma segura, utilizando Ansible Vault para proteger nuestras preciadas credenciales.

  1. ¡Elevando la seguridad! Guardando las credenciales en un archivo con Ansible Vault

Para empezar, necesitamos un lugar seguro donde guardar los nombres de usuario y contraseñas que usaremos para crear las cuentas en el servidor remoto. Ansible Vault es la herramienta perfecta para este trabajo. Ejecuta el siguiente comando en tu terminal para crear un archivo llamado credenciales_usuarios.yml: ansible-vault create credenciales_usuarios.yml Ansible te pedirá que introduzcas una contraseña súper secreta. ¡Guárdala bien, es la llave para acceder a nuestra fortaleza digital! Dentro del archivo credenciales_usuarios.yml, define una lista de usuarios con sus respectivos nombres de usuario y contraseñas:

usuarios:
  - nombre: usuario1
    usuario: usuario1
    contrasena: "contrasena_segura_1"
  - nombre: usuario2
    usuario: usuario2
    contrasena: "contrasena_segura_2"

Guarda el archivo y Ansible lo encriptará con la contraseña que elegiste. ¡Tus credenciales están a salvo!

  1. ¡A la acción! Creando usuarios con un playbook de Ansible Ahora, vamos a crear un playbook que use las credenciales almacenadas en nuestro archivo credenciales_usuarios.yml para crear las cuentas de usuario en el servidor remoto. Crea un archivo llamado crear_usuarios.yml con el siguiente contenido:
- hosts: servidores_remotos
  become: yes

  vars_files:
    - credenciales_usuarios.yml

  tasks:
    - name: Crear usuarios
      ansible.builtin.user:
        name: ""
        password: ""
        state: present
      loop: ""

¡Desglosando el playbook!

  • hosts: Define el grupo de servidores donde se crearán los usuarios. Puedes usar el nombre del grupo que definiste en tu archivo de inventario.
  • become: Le da a Ansible superpoderes para ejecutar tareas como administrador.
  • vars_files: Aquí incluimos nuestro archivo encriptado con Ansible Vault.
  • tasks: Define las tareas a ejecutar. En este caso, solo tenemos una tarea:
    • Crear usuarios: Usa el módulo user para crear las cuentas de usuario. La opción loop recorre la lista de usuarios definida en credenciales_usuarios.yml.
  1. ¡A ejecutar se ha dicho! Poniendo en marcha el playbook

Recuerda que para ejecutar el playbook con la información encriptada, necesitas proporcionar la contraseña de Ansible Vault. Puedes hacerlo al ejecutar el playbook o usando un archivo de contraseña, como te mostramos en el paso 3 del artículo anterior. Ejecuta el siguiente comando para poner en marcha nuestro plan maestro:

ansible-playbook -i hosts crear_usuarios.yml --ask-vault-pass

Ansible te pedirá la contraseña de credenciales_usuarios.yml y luego creará las cuentas de usuario en el servidor remoto. ¡Misión cumplida! ¡Seguridad y eficiencia en un solo paquete!

Con Ansible Vault y un playbook bien diseñado, podemos automatizar la creación de usuarios de forma segura y eficiente. ¡Anímate a probarlo y sigue explorando las posibilidades de Ansible!

Nota: La información sobre cómo usar Ansible Vault proviene de la documentación oficial de Ansible y no de las fuentes proporcionadas. Puedes encontrar más detalles en la página de la documentación de Ansible Vault.

]]>Organizando fotos con Python2024-11-12T00:00:00+00:002024-11-12T00:00:00+00:00https://lorcopotia.github.io/2024/11/12/Organizando-fotos-con-pythonEl poder de Python: Automatiza tu mundo

¿Te imaginas poder controlar tu computadora, tus servidores, ¡incluso tu casa inteligente con solo unas líneas de código? Eso es lo que puedes lograr aprendiendo Python, un lenguaje de programación versátil y poderoso que está conquistando el mundo.

¿Por qué Python es tan especial?

  • Es fácil de aprender: La sintaxis de Python es clara y concisa, ¡casi como leer en inglés! Esto lo convierte en un lenguaje ideal para principiantes.
  • Es muy versátil: Puedes usar Python para casi cualquier cosa: desde análisis de datos hasta desarrollo web, pasando por inteligencia artificial y automatización.
  • Tiene una gran comunidad: Millones de personas en todo el mundo utilizan Python, lo que significa que hay una gran cantidad de recursos, tutoriales y bibliotecas disponibles para ayudarte a aprender y a resolver cualquier problema que puedas tener.

¿Aún no te convences? Veamos un ejemplo práctico que te dejará con ganas de más.

Imagina que tienes un montón de fotos en tu computadora, todas desorganizadas en diferentes carpetas. Quieres ordenarlas por fecha, pero hacerlo manualmente te llevaría horas. ¡Con Python puedes hacerlo en minutos!

import os
from datetime import datetime

# Directorio donde están las fotos
directorio_fotos = "/ruta/a/tus/fotos"

# Recorrer todas las fotos en el directorio
for nombre_archivo in os.listdir(directorio_fotos):
  # Obtener la fecha de la foto
  fecha_foto = datetime.fromtimestamp(os.path.getmtime(os.path.join(directorio_fotos, nombre_archivo)))

  # Crear una carpeta para el año y el mes de la foto
  carpeta_destino = os.path.join(directorio_fotos, str(fecha_foto.year), str(fecha_foto.month))
  os.makedirs(carpeta_destino, exist_ok=True)

  # Mover la foto a la carpeta correspondiente
  os.rename(os.path.join(directorio_fotos, nombre_archivo), os.path.join(carpeta_destino, nombre_archivo))

print("¡Fotos organizadas con éxito!")

Con este simple script, Python recorre todas tus fotos, extrae la fecha de cada una y las organiza en carpetas por año y mes. ¡Adiós al caos fotográfico! Este es solo un pequeño ejemplo de lo que puedes hacer con Python. Anímate a explorar este fascinante mundo de la programación y descubre el poder de automatizar tu mundo.

]]>Utilizando Ansible Dia A Dia2024-11-04T00:00:00+00:002024-11-04T00:00:00+00:00https://lorcopotia.github.io/2024/11/04/Utilizando-Ansible-dia-a-diaAnsible en nuestro día-a-día

Automatizando la configuración de un servidor web con Ansible: Un ejemplo práctico

En el mundo actual de desarrollo y operaciones, la automatización es clave para lograr eficiencia y escalabilidad. Ansible se ha convertido en una herramienta fundamental para los equipos de DevOps, permitiéndoles automatizar la configuración y gestión de su infraestructura de manera sencilla y efectiva.

Este artículo presenta un ejemplo práctico y útil que demuestra cómo usar un playbook de Ansible para configurar un servidor web Apache en un sistema Ubuntu.

El playbook:

---
- hosts: webservers
  become: yes

  vars:
    document_root: /var/www/html
    apache_package: apache2

  tasks:
  - name: Instalar Apache
    apt: 
      name: ""
      state: present

  - name: Crear el directorio raíz del documento
    file:
      path: ""
      state: directory
      owner: www-data
      group: www-data
      mode: 0755

  - name: Copiar archivo index.html
    copy:
      src: index.html
      dest: "/index.html"
      owner: www-data
      group: www-data
      mode: 0644

  - name: Habilitar el sitio web predeterminado
    command: a2ensite default

  - name: Reiniciar Apache
    service:
      name: ""
      state: restarted

Explicación paso a paso:

  1. Definición de hosts: La primera línea define el grupo de hosts (webservers) donde se ejecutará el playbook. Es importante destacar que debes configurar tu inventario de Ansible para que incluya los servidores que pertenecen a este grupo.
  2. Privilegios de root: become: yes indica que las tareas se ejecutarán con privilegios de root.
  3. Variables: La sección vars define las variables que se utilizarán en el playbook, como la ruta del directorio raíz del documento (document_root) y el nombre del paquete de Apache (apache_package).
  4. Tareas: La sección tasks contiene la lista de tareas que se ejecutarán en los hosts especificados.
    • Instalar Apache: Esta tarea utiliza el módulo apt para instalar el paquete de Apache.
    • Crear directorio raíz: Esta tarea utiliza el módulo file para crear el directorio raíz del documento si no existe.
    • Copiar archivo index.html: Esta tarea utiliza el módulo copy para copiar un archivo index.html desde el directorio local al directorio raíz del documento en el servidor.
    • Habilitar sitio web: Esta tarea utiliza el comando a2ensite para habilitar el sitio web predeterminado en Apache.
    • Reiniciar Apache: Esta tarea utiliza el módulo service para reiniciar el servicio Apache, asegurando que los cambios se apliquen.

Beneficios de usar Ansible:

  • Idempotencia: Ansible garantiza que el servidor esté en el estado deseado, incluso si el playbook se ejecuta varias veces. Si Apache ya está instalado, Ansible no intentará reinstalarlo.
  • Simplicidad: La sintaxis YAML de Ansible es fácil de leer y entender, incluso para personas sin experiencia previa en programación.
  • Reutilización: Los playbooks de Ansible se pueden reutilizar para configurar múltiples servidores con diferentes configuraciones, lo que reduce la duplicación de esfuerzos y la posibilidad de errores.

Conclusión:

Este ejemplo práctico ilustra cómo Ansible puede simplificar significativamente la configuración de un servidor web. Con solo unas pocas líneas de código YAML, puedes automatizar todo el proceso, desde la instalación de software hasta la configuración de archivos y servicios. Ansible no solo ahorra tiempo y reduce errores, sino que también hace que la gestión de la infraestructura sea más eficiente, escalable y repetible.

]]>Utilizando HTTP2 con Docker y Nginx2024-10-12T00:00:00+00:002024-10-12T00:00:00+00:00https://lorcopotia.github.io/2024/10/12/Utilizando-HTTP2-con-Docker-NginxHTTP/2+Docker+Nginx

La idea surgió por la necesidad de habilitar HTTP/2 en Openshift y de contar con una imagen que ya estuviese preparada para desplegar y poder validad que se esta utilizando el protocolo satisfactoriamente. En esta guía utilizaré Docker.

Pasos

  1. Ejecutar los siguientes comandos para preparar los certificados que utilizaremos (estos son autofirmados para los propósitos del tutorial):

    mkdir certs
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout ./certs/nginx.key -out ./certs/nginx.crt

  2. Crear el docker-compose.yml:

    services:
  nginx:
    image: lorcopotia/my-http2-app:latest
    ports:
      - "443:443" 
    volumes:
       - ./certs:/etc/nginx/certs:ro
       #- ./html:/usr/share/nginx/html # Descomentar y poner el directorio vuestra web
 restart: always

  3. Ejecutar el siguiente comando para inicializar el contenedor:

    docker compose up -d

  4. Abrir https://localhost el tu navegador favorito e inspecciona con Developer tools. En la pestaña de Red deberias poder ver h2 en la columna protocol.

]]>