Categoría: Tutoriales

Tutoriales, how to

  • Escalado Automático en Kubernetes: Ajusta tus Aplicaciones a la Demanda

    Escalado Automático en Kubernetes: Ajusta tus Aplicaciones a la Demanda

    Introducción

    En un entorno cloud nativo, la demanda de recursos computacionales puede variar significativamente a lo largo del tiempo. Kubernetes ofrece mecanismos robustos para escalar automáticamente tus aplicaciones, asegurando que siempre tengas los recursos necesarios para satisfacer las necesidades de tus usuarios. En esta entrada, exploraremos el concepto de escalado automático en Kubernetes, sus diferentes tipos y cómo implementarlo de manera efectiva.

    ¿Qué es el Escalado Automático?

    El escalado automático es la capacidad de aumentar o disminuir automáticamente el número de réplicas de un despliegue (deployment) o estado (statefulset) en respuesta a cambios en la carga de trabajo o en las métricas definidas. Esto permite optimizar el uso de recursos, reducir costos y garantizar un alto nivel de disponibilidad.

    Tipos de Escalado Automático

    Kubernetes ofrece dos tipos principales de escalado automático:

    • Escalado Horizontal de Pods (HPA): Ajusta el número de réplicas de un despliegue basándose en métricas como la utilización de CPU o memoria. Es ideal para aplicaciones que experimentan picos de carga impredecibles.
    • Escalado Automático de Clúster: Ajusta el número de nodos en un clúster en respuesta a cambios en la demanda. Es útil para gestionar grandes clústeres con cargas de trabajo variables.

    Cómo Funciona el HPA

    1. Escalado: Si la utilización supera el umbral superior, se crean nuevas réplicas. Si la utilización cae por debajo del umbral inferior, se eliminan réplicas.
    2. Recopilación de métricas: Kubernetes recopila datos sobre el uso de CPU y memoria de los pods.
    3. Comparación con umbrales: Se compara la utilización actual con los umbrales definidos en la configuración del HPA.

    Configuración de un HPA

    Para configurar un HPA, puedes utilizar el comando kubectl autoscale o definirlo en un manifiesto YAML. Por ejemplo, para escalar un despliegue llamado “my-deployment” basado en la utilización de CPU:

    En este ejemplo:

    • minReplicas: Número mínimo de réplicas.
    • maxReplicas: Número máximo de réplicas.
    • averageUtilization: Porcentaje de utilización de CPU que desencadena el escalado.

    Consideraciones Adicionales

    • Métricas personalizadas: Puedes utilizar métricas personalizadas para el escalado, como el número de solicitudes por segundo o el tiempo de respuesta.
    • Retraso: El escalado automático no es instantáneo. Hay un cierto retraso entre el cambio en la carga de trabajo y la respuesta del escalador.
    • Costo: El escalado automático puede aumentar los costos si no se configura correctamente. Es importante establecer umbrales adecuados y monitorear el uso de recursos.
    • Estabilidad: Asegúrate de que tus aplicaciones puedan manejar cambios en el número de réplicas sin problemas.

    Conclusiones

    El escalado automático es una herramienta poderosa para gestionar la capacidad de tus aplicaciones en Kubernetes. Al configurar correctamente los HPAs, puedes optimizar el uso de recursos, mejorar el rendimiento y garantizar una alta disponibilidad.

  • Kubernetes: Port Forwarding

    Kubernetes: Port Forwarding

    Introducción

    El port forwarding en Kubernetes es una técnica esencial para desarrolladores y administradores de sistemas que desean acceder de forma directa a los servicios que se ejecutan dentro de los pods de un clúster. Esta funcionalidad permite redirigir el tráfico de un puerto local en tu máquina a un puerto específico dentro de un pod, facilitando así la depuración, las pruebas y la administración de aplicaciones. En esta guía, exploraremos en profundidad el concepto de port forwarding, sus usos más comunes y cómo implementarlo de manera efectiva.

    ¿Qué es el Port Forwarding en Kubernetes?

    El port forwarding establece una conexión TCP directa entre un puerto en tu máquina local y un puerto en un contenedor en ejecución dentro de un pod. Esto significa que cualquier solicitud que realices en tu máquina local en el puerto especificado será reenviada al contenedor correspondiente en el pod, y la respuesta será devuelta a tu máquina.

    ¿Por qué Utilizar Port Forwarding?

    • Depuración: Permite inspeccionar logs, depurar código y analizar el comportamiento de las aplicaciones en tiempo real.
    • Acceso a shells: Proporciona una forma sencilla de acceder a una shell interactiva dentro de un contenedor para ejecutar comandos.
    • Pruebas: Facilita la realización de pruebas locales sin necesidad de exponer los servicios al exterior.
    • Administración: Permite realizar tareas de administración como la configuración de bases de datos o la ejecución de scripts.

    Comandos Esenciales de Kubectl

    Antes de comenzar, asegúrate de tener kubectl instalado y configurado para interactuar con tu clúster Kubernetes. Algunos comandos útiles incluyen:

    • kubectl get pods: Lista todos los pods en ejecución.
    • kubectl describe pod <nombre-del-pod>: Muestra información detallada sobre un pod específico.
    • kubectl logs <nombre-del-pod>: Muestra los logs de un pod.

    Realizando Port Forwarding

    Para realizar port forwarding, utilizamos el comando kubectl port-forward. La sintaxis básica es la siguiente:

    • <nombre-del-pod>: El nombre del pod al que deseas conectarte.
    • <puerto-local>: El puerto en tu máquina local al que se redirigirá el tráfico.
    • <puerto-del-contenedor>: El puerto en el contenedor al que se desea conectar.

    Ejemplo:

    Este comando redirige el tráfico del puerto 8080 de tu máquina local al puerto 80 del contenedor dentro del pod llamado my-nginx-pod

    Ampliando el Ejemplo: Port Forwarding a Todas las Interfaces

    Para permitir conexiones entrantes desde cualquier interfaz de red en tu máquina, puedes utilizar el argumento --address en el comando kubectl port-forward. Esto te permitirá acceder al servicio desde cualquier máquina en la misma red, siempre y cuando conozcan la dirección IP de tu máquina.

    Ejemplo:

    Supongamos que deseas exponer el servicio Node.js de nuestro ejemplo anterior a todas las interfaces de tu máquina, utilizando el puerto 8080:

    • –address=0.0.0.0: Este argumento indica que se debe escuchar en todas las interfaces de red disponibles.

    Con esta configuración, podrás acceder a tu aplicación Node.js desde cualquier máquina de la red, usando la dirección IP de tu máquina y el puerto 8080. Por ejemplo, si la dirección IP de tu máquina es 192.168.1.100, podrás acceder a la aplicación en http://192.168.1.100:8080.

    Consideraciones Importantes:

    • Seguridad: Exponer un servicio a todas las interfaces de tu red puede comprometer la seguridad si no se toman las medidas adecuadas. Asegúrate de que tu red esté protegida por un firewall y que solo las máquinas autorizadas puedan acceder al servicio.
    • Conflictos de puertos: Si ya tienes otro servicio escuchando en el puerto 8080 en tu máquina, el port forwarding podría fallar o causar conflictos. Asegúrate de elegir un puerto libre.
    • Duración: El port forwarding se mantiene activo mientras el comando kubectl port-forward esté en ejecución. Si lo interrumpes, la conexión se cerrará.

    Otro Ejemplo: Especificando una Interfaz Específica

    Si deseas limitar el acceso a una interfaz de red específica, puedes utilizar la dirección IP de esa interfaz en lugar de 0.0.0.0. Por ejemplo, si deseas escuchar solo en la interfaz eth0:

    Consideraciones Adicionales

    • Port forwarding estático: Para establecer un port forwarding de forma más permanente, puedes utilizar herramientas como kubectl proxy o configurar un servicio de tipo NodePort.
    • Seguridad: Ten en cuenta que el port forwarding expone los servicios de tu pod directamente a tu máquina local. Utiliza firewalls y otras medidas de seguridad para proteger tu entorno.
    • Múltiples contenedores: Si un pod tiene múltiples contenedores, puedes especificar el nombre del contenedor después del nombre del pod en el comando kubectl port-forward.

    Conclusión

    El port forwarding es una herramienta invaluable para desarrolladores y administradores de Kubernetes. Al comprender cómo funciona y cómo utilizarlo de manera efectiva, puedes mejorar significativamente tu flujo de trabajo y facilitar la resolución de problemas.

  • Cómo Integrar ExternalDNS con Cloudflare y Traefik v3 en Kubernetes

    Cómo Integrar ExternalDNS con Cloudflare y Traefik v3 en Kubernetes

    La integración de ExternalDNS con Traefik v3 en Kubernetes es una combinación poderosa que facilita la gestión automática de registros DNS para los servicios desplegados en tu clúster. En esta guía detallada, te mostraremos cómo configurar esta integración paso a paso.

    1. Introducción a ExternalDNS y Traefik

    ExternalDNS es una herramienta que actualiza automáticamente los registros DNS en tu proveedor DNS cuando cambian los servicios en tu clúster de Kubernetes. Traefik es un proxy inverso y balanceador de carga que simplifica la gestión de rutas y servicios en Kubernetes.

    2. Prerrequisitos

    Antes de comenzar, asegúrate de tener lo siguiente:

    • Un clúster de Kubernetes en funcionamiento.
    • Traefik v3 instalado en tu clúster.
    • Un dominio gestionado por un proveedor de DNS compatible con ExternalDNS, en este caso Cloudflare.
    • kubectl configurado para interactuar con tu clúster.

    3. Instalación de ExternalDNS

    Primero, instalaremos ExternalDNS usando Helm, un gestor de paquetes para Kubernetes.

    Luego, creamos un archivo values.yaml para personalizar la instalación de ExternalDNS:

    Instalamos ExternalDNS con Helm usando el archivo values.yaml:

    4. Configuración de Traefik v3

    Asegúrate de tener Traefik v3 instalado y configurado. Puedes instalarlo usando Helm también:

    5. Configuración de IngressRoutes en Traefik

    Para que ExternalDNS funcione con Traefik, necesitamos configurar IngressRoutes. Aquí hay un ejemplo básico:

    Hay que tener en cuenta que en el caso de Traefik, externaldns no crea un registro DNS tipo A, sino un registro CNAME, y el valor de ese CNAME registro es el valor de external-dns.alpha.kubernetes.io/target

    6. Verificación de la Configuración

    Después de aplicar la configuración, verifica que ExternalDNS esté creando los registros DNS correspondientes.

    Deberías ver registros que indiquen que ExternalDNS está sincronizando registros DNS.

    Deberías ver registros que indiquen que ExternalDNS está sincronizando registros DNS.

    7. Solución de Problemas Comunes

    • Permisos de API: Asegúrate de que tu token de API de Cloudflare tenga los permisos necesarios.
    • Configuración de DNS: Verifica que tu proveedor DNS esté correctamente configurado en el archivo values.yaml.
    • Logs de ExternalDNS: Revisa los logs de ExternalDNS para identificar problemas específicos.

    8. Beneficios de la Integración

    Integrar ExternalDNS con Traefik proporciona varios beneficios:

    • Automatización: Los registros DNS se actualizan automáticamente cuando cambian los servicios en Kubernetes.
    • Simplificación: Menos configuraciones manuales y errores.
    • Escalabilidad: Ideal para entornos de producción con múltiples servicios.

    9. Mejoras Adicionales

    • Monitoreo: Implementa monitoreo para ExternalDNS y Traefik usando herramientas como Prometheus y Grafana.
    • Seguridad: Asegúrate de que las conexiones entre componentes sean seguras.

    Conclusiones

    La integración de ExternalDNS con Traefik v3 en Kubernetes mejora significativamente la eficiencia y la gestión de los registros DNS en tu clúster. Automatiza procesos y reduce errores, proporcionando una solución robusta y escalable.

    Recursos Adicionales

  • Automatización de Infraestructura con Terraform: Tutorial Básico

    Automatización de Infraestructura con Terraform: Tutorial Básico

    La automatización de infraestructura es una necesidad crucial en el desarrollo y operaciones modernas. Terraform, una herramienta de infraestructura como código (IaC) de HashiCorp, permite a los desarrolladores y administradores de sistemas definir y aprovisionar recursos de infraestructura en varios proveedores de servicios en la nube de manera eficiente y reproducible. En este tutorial básico, aprenderemos cómo empezar con Terraform, desde la instalación hasta la configuración de un recurso simple en AWS.

    1. ¿Qué es Terraform?

    Terraform es una herramienta de código abierto que permite a los usuarios definir y aprovisionar infraestructura utilizando un lenguaje declarativo llamado HashiCorp Configuration Language (HCL). La principal ventaja de Terraform es que es independiente del proveedor de servicios en la nube, lo que significa que puede gestionar recursos en AWS, Azure, Google Cloud y otros.

    2. Instalación de Terraform

    Antes de empezar, necesitamos instalar Terraform en nuestra máquina local. Los pasos para la instalación pueden variar según el sistema operativo:

    En Linux:

    En macOS:

    En Windows:

    Descarga el archivo binario desde la página de releases de Terraform y sigue las instrucciones de instalación.

    3. Configuración de AWS CLI

    Para interactuar con AWS, necesitamos configurar AWS CLI con nuestras credenciales. Si aún no tienes AWS CLI instalado, puedes hacerlo siguiendo estos pasos:

    En Linux y macOS:

    En Windows:

    Descarga el instalador de AWS CLI desde la página oficial y sigue las instrucciones de instalación.

    Una vez instalado, configura AWS CLI:

    Introduce tu Access Key ID, Secret Access Key, región por defecto (por ejemplo, us-west-2), y el formato de salida (por ejemplo, json).

    4. Creación de un Proyecto de Terraform

    Crea un directorio para tu proyecto de Terraform:

    5. Escribiendo el Archivo de Configuración de Terraform

    Crea un archivo llamado main.tf en tu directorio de proyecto. Este archivo definirá los recursos que queremos crear en AWS. Vamos a empezar con un recurso simple: una instancia EC2.

    6. Inicialización del Proyecto de Terraform

    Antes de aplicar cualquier cambio, necesitamos inicializar el proyecto de Terraform. Esto descargará los proveedores necesarios y preparará el directorio de trabajo.

    Salida esperada:

    7. Planificación y Aplicación de los Cambios

    El siguiente paso es crear un plan de ejecución. Terraform mostrará qué recursos serán creados, modificados o eliminados.

    Salida esperada (resumen):

    Para aplicar los cambios, ejecuta:

    Terraform te pedirá confirmar antes de proceder. Escribe yes para continuar. Salida esperada (resumen):

    8. Verificación del Recurso

    Una vez que Terraform haya creado la instancia, puedes verificar su existencia en la consola de AWS EC2 o utilizando el siguiente comando de AWS CLI:

    Salida esperada (resumen):

    9. Limpieza

    Para eliminar los recursos creados, usa el comando terraform destroy:

    Terraform te pedirá confirmar antes de proceder. Escribe yes para continuar. Salida esperada (resumen):

    Conclusión

    En este tutorial, hemos cubierto los pasos básicos para instalar y configurar Terraform, crear un proyecto, definir y desplegar una instancia EC2 en AWS. Terraform es una herramienta poderosa que permite la gestión y automatización de infraestructura de manera eficiente y reproducible. A medida que te sientas más cómodo con los conceptos básicos, puedes explorar configuraciones más avanzadas y la integración con otros servicios y proveedores de la nube.

  • Introducción a Kubernetes: Desplegando tu Primer Pod

    Introducción a Kubernetes: Desplegando tu Primer Pod

    Kubernetes se ha convertido en la plataforma estándar para la orquestación de contenedores. Permite gestionar aplicaciones en contenedores de manera automática, escalable y eficiente. En esta guía, aprenderás cómo desplegar tu primer Pod en un cluster de Kubernetes, cubriendo desde la instalación hasta la verificación del despliegue.

    1. ¿Qué es Kubernetes?

    Kubernetes es un sistema de código abierto para la automatización de la implementación, el escalado y la gestión de aplicaciones en contenedores. Fue desarrollado por Google y donado a la Cloud Native Computing Foundation (CNCF). Sus componentes principales incluyen:

    • Pod: La unidad más pequeña y simple en Kubernetes, que puede contener uno o varios contenedores.
    • Node: Un servidor físico o virtual que ejecuta pods.
    • Cluster: Un conjunto de nodes gestionados por Kubernetes.

    2. Preparativos para el Despliegue

    Antes de empezar, necesitas un cluster de Kubernetes. Puedes usar Minikube para crear un cluster local o un servicio gestionado como Google Kubernetes Engine (GKE), Amazon Elastic Kubernetes Service (EKS) o Azure Kubernetes Service (AKS). En esta guía, usaremos Minikube.

    Instalación de Minikube
    • Instalar Minikube: Sigue las instrucciones específicas para tu sistema operativo desde Minikube.
    curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
    sudo install minikube-linux-amd64 /usr/local/bin/minikube
    
    • Iniciar Minikube:
    minikube start
    

    Este comando inicia un cluster local de Kubernetes en una máquina virtual.

    • Verificar la instalación:

    La salida debe mostrar un node en estado Ready.

    3. Desplegando tu Primer Pod

    Un Pod es la unidad de despliegue básica en Kubernetes. Vamos a crear un Pod que ejecute una instancia de Nginx.

    Crear un Archivo de Configuración YAML

    Crea un archivo llamado nginx-pod.yaml con el siguiente contenido:

    Este archivo define un Pod llamado nginx-pod que ejecuta el contenedor Nginx en el puerto 80.

    Aplicar el Archivo de Configuración

    Usa kubectl para crear el Pod a partir del archivo YAML:

    Este comando crea el Pod en el cluster de Kubernetes.

    4. Verificar el Despliegue

    Para asegurarte de que el Pod se ha creado correctamente, usa:

    Deberías ver nginx-pod con el estado Running.

    5. Acceder al Pod

    Para acceder al Nginx que se está ejecutando en el Pod, necesitas exponer el Pod. Esto se puede hacer mediante el comando kubectl port-forward:

    Ahora, puedes abrir tu navegador y visitar http://localhost:8080 para ver la página de bienvenida de Nginx.

    6. Limpieza

    Para eliminar el Pod, usa:

    Este comando eliminará el Pod del cluster.

    7. Conclusión

    Desplegar un Pod en Kubernetes es el primer paso para aprovechar las capacidades avanzadas de esta plataforma de orquestación. Ahora que has desplegado y accedido a tu primer Pod, puedes explorar características más avanzadas como despliegues, servicios y configuración de volúmenes persistentes.

  • Automatización de Tareas en Linux con Cron y Shell Scripting

    Automatización de Tareas en Linux con Cron y Shell Scripting

    La automatización de tareas en Linux es una habilidad esencial para cualquier administrador de sistemas o desarrollador. Nos permite programar y ejecutar tareas de manera automática, lo que ahorra tiempo y reduce el riesgo de errores humanos. En esta guía, exploraremos cómo utilizar cron y scripts de shell para automatizar tareas en Linux.

    Introducción a Cron

    cron es un demonio de Unix/Linux que permite a los usuarios programar tareas (también conocidas como “jobs”) para que se ejecuten en intervalos regulares. Los trabajos cron se definen en archivos llamados crontabs.

    Sintaxis de Crontab

    Un archivo crontab tiene una sintaxis específica que se usa para definir cuándo se debe ejecutar un trabajo. La sintaxis general es:

    Ejemplos de Crontab

    Ejecutar un comando cada 5 minutos

    Para ejecutar un comando cada 5 minutos, la línea en crontab se vería así:

    Ejecutar un script de shell diariamente a la medianoche

    Para ejecutar un script de shell todos los días a la medianoche:

    Ejecutar un comando cada lunes a las 8:30 AM

    Para ejecutar un comando cada lunes a las 8:30 AM:

    Creación y Edición de Crontabs

    Ver el Crontab Actual

    Para ver el crontab actual del usuario, ejecuta:

    Editar el Crontab

    Para editar el crontab del usuario, usa:

    Esto abrirá el crontab en el editor de texto predeterminado, donde puedes agregar, editar o eliminar tareas.

    Eliminar el Crontab

    Para eliminar el crontab del usuario:

    Shell Scripting para Automatización

    Los scripts de shell son programas escritos en un lenguaje de scripting que se ejecutan en el intérprete de comandos. Son útiles para automatizar tareas repetitivas y pueden ser combinados con cron para una automatización potente.

    Creación de un Script de Shell

    Un script de shell básico puede parecerse a esto:

    Explicación del Script

    • #!/bin/bash: Shebang que indica al sistema qué intérprete usar.
    • FECHA=$(date +%Y%m%d): Asigna la fecha actual en formato YYYYMMDD a la variable FECHA.
    • DIRECTORIO_ORIGEN y DIRECTORIO_DESTINO: Definen los directorios de origen y destino para la copia de seguridad.
    • tar -czf $DIRECTORIO_DESTINO/backup_$FECHA.tar.gz $DIRECTORIO_ORIGEN: Crea un archivo comprimido tar.gz con el contenido del directorio de origen.

    Programación del Script con Cron

    Para ejecutar el script de copia de seguridad diariamente a las 2 AM, agrega la siguiente línea al crontab:

    Mejores Prácticas

    • Verificar las rutas: Asegúrate de que las rutas en los scripts y crontabs son absolutas para evitar errores.
    • Registro de Salidas: Redirige las salidas y errores de los comandos a archivos de log para su análisis:
    • Pruebas: Prueba tus scripts y tareas cron manualmente antes de programarlas para asegurarte de que funcionan correctamente.

    Herramientas Adicionales

    • anacron: Para tareas que deben ejecutarse incluso si el sistema estuvo apagado.
    • at: Para programar tareas que deben ejecutarse una sola vez en el futuro.

    Conclusión

    La automatización de tareas en Linux con cron y scripts de shell es una técnica poderosa que puede ahorrarte tiempo y esfuerzo. Con esta guía, tienes las herramientas necesarias para empezar a programar y automatizar tus propias tareas en Linux.

  • Cómo cambiar la swappiness en CentOS y Ubuntu

    Cómo cambiar la swappiness en CentOS y Ubuntu

    La configuración de swappiness en Linux puede mejorar el rendimiento del sistema. Aprende a ajustarla en CentOS y Ubuntu con estos simples pasos.

    1. Comprender swappiness:

    La swappiness controla la preferencia del kernel de Linux para utilizar el intercambio de memoria en lugar de la RAM física. Un valor bajo prioriza la RAM, mientras que uno alto prioriza el intercambio.

    2. Verificar el valor actual:

    Muestra el valor actual de swappiness.

    Ejemplo:

    3. Cambiar swappiness temporalmente:

    Ajusta temporalmente la swappiness a 20. Puedes cambiar el valor según tus preferencias.

    Ejemplo:

    4. Verificar cambio temporal:

    Confirma que el cambio temporal se aplicó.

    Ejemplo:

    5. Cambiar swappiness permanentemente en CentOS:

    Agrega la configuración a /etc/sysctl.conf y aplica los cambios permanentes.

    Ejemplo:

    6. Cambiar Swappiness Permanentemente en Ubuntu:

    Puedes cambiarla con el comando anterior o realizar lo siguiente:

    Edita el archivo de configuración y aplica los cambios

    Añade la línea vm.swappiness=20 al final del archivo. Guarda y cierra el editor.

    7. Verificar Cambio Permanente:

    Confirma que el cambio permanente se aplicó.

    Ejemplo:

    Conclusión:

    Optimiza el rendimiento de tu sistema ajustando la swappiness. Experimenta con diferentes valores para encontrar el equilibrio perfecto.

  • Instalación de Jellifyn en Raspberry Pi

    Instalación de Jellifyn en Raspberry Pi

    Jellyfin, una poderosa solución de medios, puede convertir tu Raspberry Pi en un centro multimedia personal. Sigue estos pasos para instalarlo.

    Paso 1: Actualiza el Sistema

    Actualiza la lista de paquetes y realiza la actualización del sistema.

    Paso 2: Instala Dependencias Necesarias

    Paso 3: Descarga la clave de firma GPG

    Descarga la clave de firma GPG (firmada por el equipo de Jellyfin) e instálala

    Paso 4: Añade configuración de repositorio

    Añade una configuración de repositorio en /etc/apt/sources.list.d/jellyfin.sources:

    Paso 5: Actualiza el sistema para aplicar cambios

    Actualiza la lista de paquetes para incluir el nuevo repositorio.

    Paso 6: Instala Jellyfin

    Instala Jellyfin en tu Raspberry Pi

    Paso 7: Inicia el servicio Jellyfin

    Inicia el servicio Jellyfin y configúralo para que se inicie automáticamente con el sistema.

    Paso 8: Accede a Jellyfin desde tu Navegador

    Utiliza la dirección IP de tu Raspberry Pi seguida del puerto 8096 para acceder a la interfaz web de Jellyfin

    Para obtener la IP de tu Raspberry pi:

    Para más detalles puedes visitar la página oficial https://jellyfin.org/docs/general/installation/linux

    ¡Felicidades! Ahora, tu Raspberry Pi funciona como un completo centro multimedia con Jellyfin. Organiza y transmite tus contenidos multimedia de manera eficiente.

  • Cómo verificar la conexión a Internet en Linux mediante comandos

    Cómo verificar la conexión a Internet en Linux mediante comandos

    Mantenerse conectado a Internet es esencial. Aprende a usar comandos en Linux para verificar tu conexión en cualquier momento.

    1. Comprobación básica con Ping

    Obtiene las cabeceras HTTP, confirmando la conectividad.

    2. Utilizando Curl para test de conexión

    Obtiene las cabeceras HTTP, confirmando la conectividad

    3. Prueba de resolución de DNS

    Verifica si el sistema puede resolver nombres de dominio.

    4. Utilizando el Comando Dig para Pruebas DNS

    Proporciona información detallada sobre la resolución de DNS.

    5. Prueba de resolución de DNS con Host

    Verifica si el sistema puede resolver nombres de dominio.

    6. Comprobación de la conexión SSL/TLS

    Verifica la conexión SSL/TLS con el servidor.

    7. Comprobación de la conexión con Nmap

    Verifica la conexión con el servidor 8.8.8.8.

    Ahora puedes asegurarte de tu conectividad a Internet utilizando estos comandos en Linux. ¡Mantente siempre online y explorando el mundo digital!

  • Ampliando el sistema de archivos en CentOS 7 con LVM después de expandir el disco en VMware

    Ampliando el sistema de archivos en CentOS 7 con LVM después de expandir el disco en VMware

    En entornos virtuales, como VMware, puede surgir la necesidad de expandir el espacio en disco de una máquina virtual (VM) cuando el sistema de archivos está gestionado por Logical Volume Manager (LVM). A continuación, te guiaré a través de los pasos para expandir el sistema de archivos en CentOS 7 después de haber ampliado el disco en VMware.

    Paso 1: Verificar el Espacio Disponible en el Disco

    Antes de realizar cualquier acción, verifica el espacio disponible en el disco. Puedes hacerlo utilizando el comando lsblk para listar los bloques de almacenamiento.

    Este comando mostrará la estructura de bloques de almacenamiento en tu sistema, incluyendo los discos y las particiones, por ejemplo:

    Si el sistema operativo no detecta el incremento de disco

    Si el sistema operativo aún no toma los cambios realizados al disco desde VMware y no se puede reiniciar el equipo, se puede realizar lo siguiente:

    1. Listar los dispositivos de disco del equipo con el comando:
      ls /sys/class/scsi_device/
      Ejemplo de salida:
      # ls /sys/class/scsi_device/
      1:0:0:0 2:0:0:0 2:0:1:0 2:0:2:0
    2. Ejecutar el siguiente comando por cada dispositivo de disco listado con el comando anterior:
      echo 1 > /sys/class/scsi_device/N\:N\:N\:N/device/rescan
      Ejemplo:
      echo 1 > /sys/class/scsi_device/1\:0\:0\:0/device/rescan
      echo 1 > /sys/class/scsi_device/2\:0\:0\:0/device/rescan
      echo 1 > /sys/class/scsi_device/2\:0\:1\:0/device/rescan
      echo 1 > /sys/class/scsi_device/2\:0\:2\:0/device/rescan
    3. Verificar el tamaño de los discos con el comando:
      lsblk

    Paso 2: Incrementar la partición del disco

    Antes de expandir la partición creada con LVM, es necesario expandir la partición del disco. Para realizarlo vamos a utilizar la herramienta growpart . Para utilizar la herramienta, necesitamos tener identificado el disco y la partición a agrandar. Ejecutar el siguiente código:

    Por ejemplo /dev/sdc y la primer partición:

    Chequear los cambios con el comando:

    Instalar growpart

    Si no tienes instalada la herramienta growpart, se puede instalar ejecutando el siguiente comando:

    Paso 3: Expandir el Volumen Físico (PV) en LVM

    En este paso, expandiremos el volumen físico para que pueda utilizar el espacio adicional en el disco recién agregado. Utiliza el comando pvresize seguido del camino del dispositivo físico.

    Siguiendo el ejemplo anterior:

    Paso 4: Ampliar el Volumen Lógico (LV) en LVM

    Ahora, es el momento de expandir el volumen lógico para que pueda utilizar el espacio adicional en el volumen físico. Utiliza el comando lvextend con el camino del volumen lógico y la cantidad de espacio que deseas agregar.

    Asegúrate de reemplazar /dev/mi_grupo_volumen/mi_volumen_logico con la ruta correcta de tu volumen lógico.

    Paso 5: Ampliar el Sistema de Archivos

    Finalmente, necesitas expandir el sistema de archivos en el volumen lógico para que pueda utilizar el espacio recién agregado. El comando específico puede variar según el tipo de sistema de archivos que estés utilizando. Para un sistema de archivos ext4, por ejemplo, puedes usar el siguiente comando:

    O con el siguiente comando si tu sistema de archivo es xfs :

    Asegúrate de reemplazar /dev/mi_grupo_volumen/mi_volumen_logico con la ruta correcta de tu volumen lógico.

    Paso 6: Verificar la Ampliación del Sistema de Archivos

    Verifica que el sistema de archivos se haya ampliado correctamente utilizando el comando df -h.

    Esto mostrará la información del sistema de archivos, incluyendo el tamaño actualizado después de la expansión.

    Con estos pasos, has logrado expandir el sistema de archivos en CentOS 7 después de haber ampliado el disco en VMware. Recuerda siempre realizar copias de seguridad antes de realizar cambios en el almacenamiento para evitar pérdida de datos. ¡Ahora disfruta de tu espacio de almacenamiento adicional!