Conectar cliente Cloudflare a un túnel que ya existente

 Debes tener instalado en cliente de túnel de Cloudflare y ejecutar el siguiente comando:

 

cloudflared service install token

 

se instala como un servicio de linux

 

LXC: Crear perfiles para limitar recursos de CPU y memoria

Traducción de la siguiente pagina 

Las instancias LXD se pueden limitar a la cantidad de recursos de CPU y memoria utilizados por el servidor host. Estos límites se pueden establecer en cada instancia individual o mediante el uso de perfiles. Esta guía práctica creará un perfil que establezca estos límites y luego lo aplicará a una instancia. Un solo perfil se puede reutilizar y aplicar a varias instancias.

Llamaremos al nuevo perfil cpu2-memory4, nombrándolo de una manera que identifique fácilmente su propósito. Configuraremos el perfil para limitar la instancia a 2 CPU virtuales y también a 4 GB de memoria. Para crear el nuevo perfil, ejecute el siguiente comando:

$ lxc profile create cpu2-memory4

Ahora tenemos un perfil vacío sin ninguna configuración. Para obtener una lista de los perfiles que tiene en su servidor LXD y ver el perfil cpu2-memory4 recién creado, ejecute el siguiente comando:

$ lxc profile list
+---------------+---------+
|    NOMBRE       | USADO POR |
+---------------+---------+
| default       | 2       |
+---------------+---------+
| cpu2-memory4  | 0       |
+---------------+---------+

El nuevo perfil ahora se puede modificar para limitar el uso de CPU y memoria. Podemos elegir editar el perfil directamente usando un editor (lxc profile edit cpu2-memory4) o establecer límites usando opciones de línea de comandos basadas en LXC.

Eligiendo la última opción, podemos establecer ambos límites de configuración al mismo tiempo con un solo comando. Establezcamos el límite de CPU a 2 CPU virtuales y el límite de memoria a 4GB de RAM ejecutando el siguiente comando:

$ lxc profile set cpu2-memory4 limits.cpu=2 limits.memory=4GB

Para ver el contenido del perfil use el siguiente comando:

$ lxc profile show cpu2-memory4
config:
  limits.cpu: "2"
  limits.memory: 4GB
description: ""
devices: {}
name: cpu2-memory4
used_by: []

Si está iniciando una nueva instancia, puede usar la opción –-profile (o -p) para agregar perfiles a la instancia a medida que se crea. Pero si la instancia ya existe, tendrá que agregar el nuevo perfil a la instancia. Supongamos que tenemos una instancia llamada vm1. Para agregar el perfil cpu2-memory4 a esta instancia, use el siguiente comando:

$ lxc profile add vm1 cpu2-memory4

Para mostrar la configuración aplicada a su instancia, use el siguiente comando:

$ lxc config show vm1 -e

La configuración del perfil se puede eliminar de la instancia. Para eliminar el perfil use el siguiente comando:

$ lxc profile remove vm1 cpu2-memory4

Cuando elimina el perfil de la instancia, el perfil aún existe y se puede usar para otras instancias. Si desea eliminar el perfil permanentemente, se puede eliminar con el siguiente comando:

$ lxc profile delete cpu2-memory4

LXC: Limitar recursos de memoria

En LXC al igual que con otras tecnologías de virtualización, es posible limitar la cantidad de memoria RAM que puede usar cada contenedor LXC. Esto puede ser útil para aislar aplicaciones con uso intensivo de memoria y evitar que un solo contenedor consuma todos los recursos disponibles del sistema.

Existen dos métodos principales para limitar la memoria RAM en LXC:

1. Utilizando el comando lxc config set

El comando lxc config set permite establecer diversas configuraciones para los contenedores LXC, incluida la cantidad de memoria RAM que pueden usar. La sintaxis para limitar la memoria RAM de un contenedor es la siguiente:

lxc config set <nombre_contenedor> limits.memory <valor_memoria>

Donde:

• <nombre_contenedor> es el nombre del contenedor para el que desea establecer el límite de memoria RAM.
• <valor_memoria> es la cantidad de memoria RAM que desea asignar al contenedor, especificada en bytes. Puede usar sufijos como M para megabytes o G para gigabytes.

Por ejemplo, para limitar la memoria RAM del contenedor nginx-proxy a 512 megabytes, ejecute el siguiente comando:

lxc config set nginx-proxy limits.memory 512M

2. Modificando el archivo de configuración del contenedor

Los contenedores LXC también pueden configurarse mediante archivos de configuración. Estos archivos contienen información sobre las características y recursos del contenedor. Para limitar la memoria RAM de un contenedor utilizando un archivo de configuración, siga estos pasos:

1. Abra el archivo de configuración del contenedor que desea modificar. El archivo de configuración se encuentra generalmente en /var/lib/lxc/<nombre_contenedor>/config.
2. Busque la línea que comienza con lxc.cgroup.memory.limit_in_bytes. Si esta línea no existe, agréguela al final del archivo.
3. Establezca el valor de la línea lxc.cgroup.memory.limit_in_bytes a la cantidad de memoria RAM que desea asignar al contenedor, especificada en bytes. Puede usar sufijos como M para megabytes o G para gigabytes.
4. Guarde el archivo de configuración.

Por ejemplo, para limitar la memoria RAM del contenedor nginx-proxy a 512 megabytes en el archivo de configuración, agregue la siguiente línea al final del archivo:

lxc.cgroup.memory.limit_in_bytes = 512M

Consideraciones adicionales

• Es importante tener en cuenta que la cantidad de memoria RAM que asigna a un contenedor debe ser suficiente para que el contenedor funcione correctamente. Si asigna demasiada poca memoria RAM, el contenedor puede experimentar problemas de rendimiento o incluso fallar.
• También es importante tener en cuenta que la memoria RAM asignada a un contenedor no es exclusiva. El contenedor aún puede acceder a la memoria RAM disponible en el sistema host, pero estará limitado por la cantidad que haya configurado.
• Si necesita limitar aún más los recursos de un contenedor, puede utilizar otras opciones de configuración de LXC, como limits.cpu para limitar el uso de la CPU o limits.network para limitar el uso de la red.

Espero que esta información le sea útil. Si tiene alguna otra pregunta, no dude en preguntar.

LXC: limitar recursos de CPU

 

Traducción del siguiente articulo 

La administración de contenedores Linux (LXC) ahora se maneja a menudo con LXD, el proyecto principal de Canonical construido sobre LXC. LXD ofrece un conjunto de opciones para controlar los recursos de los contenedores Linux y establecer límites cuando sea apropiado. Esta publicación hablará sobre cómo establecer restricciones en la CPU, sin embargo, hay otras opciones disponibles para limitar casi cualquier tipo de recurso, como red, E/S de disco, memoria, etc.

Límites disponibles

La administración de la CPU se realiza de 1 de 4 maneras, según su carga de trabajo esperada y el régimen de administración de la CPU del host.

• Número de CPU: define la cantidad de núcleos de CPU que LXC puede usar con este contenedor y distribuye automáticamente el tiempo de CPU entre los invitados cuando hay competencia por el tiempo de CPU. El valor utilizado es un número entero, por ejemplo 2.
• Núcleos específicos: especifica núcleos físicos específicos para que los use el contenedor y distribuye el tiempo de CPU disponible entre contenedores cuando varios contenedores usan los mismos núcleos. El valor utilizado es un número entero o rango y puede estar separado por comas, por ejemplo 2, 0-1 o 0-1,3,5-9.
• Participación limitada: permite un porcentaje específico de tiempo de CPU para el contenedor, o más si está disponible. Cuando el host no está bajo carga, un contenedor puede usar cualquier CPU disponible, pero cuando hay contención por la CPU, el contenedor se limitará a la cantidad especificada. El contenedor verá todos los núcleos de CPU del host (en TOP, por ejemplo).
• Comparte de tiempo limitado: limitará el tiempo de CPU del contenedor a lo que se especifique de cada 200ms. Incluso si hay más CPU disponible, solo se permite lo que se especifica por porción de 200ms. El contenedor verá todos los núcleos de CPU del host (en TOP, por ejemplo).

Establecimiento de límites

El establecimiento de límites se realiza con el comando lxc. Luego hay dos opciones; limits.cpu para los puntos anteriores 1 y 2, o limit.cpu.allowance para los puntos 3 y 4.

lxc config set [CONTENEDOR] limits.cpu [VALOR]

• [CONTENEDOR] es el nombre del contenedor; se puede obtener de lxc list si no está seguro.
• [VALOR] es un valor válido del punto 1 o 2 anterior.

O

lxc config set [CONTENEDOR] limits.cpu.allowance [VALOR]

• [CONTENEDOR] es el nombre del contenedor; se puede obtener de lxc list si no está seguro.
• [VALOR] es un valor válido del punto 3 o 4 anterior.

Ejemplos de límite de CPU

• Configure el contenedor nginx-proxy para que use cualquiera de las 2 CPU en el host.

lxc config set nginx-proxy limits.cpu 2

• Configure el contenedor nginx-proxy para que use las CPU físicas 0, 3, 7, 8 y 9 en el host.

lxc config set nginx-proxy limits.cpu 0,3,7-9

• Configure el contenedor nginx-proxy para que use el 20% de la CPU disponible en el host o más si está disponible.

lxc config set nginx-proxy limits.cpu.allowance 20%

• Configure el contenedor nginx-proxy para que use no más del 50% de la CPU disponible en el host, o 100 ms por cada 200 ms de tiempo de CPU disponible.

lxc config set nginx-proxy limits.cpu.allowance 100ms/200ms

Puede ver /proc/cpuinfo para ver los núcleos disponibles en su contenedor, sin embargo, no incluirá ningún límite de programación o prioridad adicional.

cat /proc/cpuinfo | grep processor
processor: 0
processor: 1

Prioridad de CPU

La última opción relacionada con la limitación de CPU es la prioridad del tiempo de CPU. Esta opción solo se activa cuando el host está sobrecargado en recursos de CPU y los contenedores están luchando por el tiempo de CPU. Esto puede ocurrir en un solo núcleo (si se usan los puntos anteriores 1 o 2) o en todo el sistema (si no hay limitación de CPU en uso o si se usan los puntos anteriores 3 o 4).

Los valores disponibles van de 0 a 10 (inclusive). Los números más bajos significan una prioridad más baja, mientras que un número más alto significa que la máquina obtendrá tiempo de CPU antes que los números más bajos.

El siguiente comando establece una prioridad de CPU de 5 para el contenedor nginx-proxy:

lxc config set nginx-proxy limits.cpu.priority 5

El siguiente comando establece una prioridad de CPU de 2 para el contenedor php-backend, por lo que obtendría menos tiempo de CPU que el contenedor nginx-proxy cuando la CPU esté en contención.

lxc config set php-backend limits.cpu.priority 5 

Cómo instalar un cluster de MicroK8s en tres contenedores LXC, instalados en Ubuntu

Introducción

MicroK8s es una plataforma de Kubernetes simplificada que permite implementar y ejecutar aplicaciones en contenedores de forma fácil y rápida. En este artículo, se describe cómo instalar un cluster de MicroK8s en tres contenedores LXC, instalados en Ubuntu.

Requisitos previos

• Una máquina con Ubuntu y LXC instalado
  
• Conocimiento básico de Linux y contenedores LXC.

Pasos

1. Instalar LXC

En la máquina Ubuntu, instale el paquete LXC utilizando el siguiente comando:

sudo apt install lxc

 

2. Crear perfil microk8s

Debemos crear un perfil para que kubernetes se ejecute sin problemas en un contenedor LXC:

lxc profile create microk8s

# para ZFS
wget https://raw.githubusercontent.com/ubuntu/microk8s/master/tests/lxc/microk8s-zfs.profile -O microk8s.profile
# para ext4
wget https://raw.githubusercontent.com/ubuntu/microk8s/master/tests/lxc/microk8s.profile -O microk8s.profile

cat microk8s.profile | lxc profile edit microk8s

rm microk8s.profile  

2. Crear contenedor LXC base

Primero debemos crear un contenedor LXC utilizando utilizando el perfil microk8s, instalamos microk8s y después generamos una sanpshot de es:

lxc launch -p default -p microk8s ubuntu:22.04 microk8s01

#instalamos microk8s

lxc exec microk8s01 -- sudo snap install microk8s --classic  

#creamos el snapshot 

lxc snapshot microk8s01 microk8s-template

3. Crear los otros contenedores

En base a la snapshot creamos los otros dos contenedores:

#contenedor 2

lxc copy microk8s-template microk8s02

#contenedor 3
lxc copy microk8s-template microk8s03

4. Agregar nodos al cluster

Ya tenemos microk8s en tres maquinas, asi que ahora los uniremos entre ellos. Para eso desde el nodo microk8s01 ejecutaremos el siguiente comando:

root@microk8s01:~# microk8s add-node
From the node you wish to join to this cluster, run the following:
microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e

Use the '--worker' flag to join a node as a worker not running the control plane, eg:
microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e --worker

If the node you are adding is not reachable through the default interface you can use one of the following:
microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e

 Donde <token> es el token de unión proporcionado por el primer nodo  y <apiserver-url> es la URL del servidor API de MicroK8s del primer nodo. Desde los demas nodos ejecutaremos el siguiente comando

microk8s join 10.88.89.67:25000/da2fc5b4a60fc1e5fbbe703b007414c3/4523e5f8424e

5. Verificar Cluster

Verifique que el cluster de MicroK8s esté funcionando correctamente utilizando el siguiente comando:

root@microk8s01:~# microk8s status 
microk8s is running
high-availability: yes
  datastore master nodes: 10.88.89.67:19001 10.88.89.59:19001 10.88.89.165:19001
  datastore standby nodes: none

root@microk8s01:~# microk8s kubectl get no
NAME         STATUS   ROLES    AGE     VERSION
microk8s01   Ready    <none>   8m24s   v1.29.4
microk8s02   Ready    <none>   89s     v1.29.4
microk8s03   Ready    <none>   9s      v1.29.4

Conclusión

Ha completado la instalación de un cluster de MicroK8s en tres contenedores LXC, instalados en Ubuntu. Ahora puede implementar y ejecutar aplicaciones en contenedores en su cluster de MicroK8s.

Recursos adicionales

• Documentación de MicroK8s

API de Geo IP en Python

import pandas as pd
import requests

#IPs a revisar

ips = ["54.86.50.139","191.113.136.20"]

#Consulta a ip-api y la salida se  guarda en Pandas

response = requests.post("http://ip-api.com/batch", json=ips).json()    response = pd.DataFrame(response)

#Imprimimos la salida

print(response)

#y tambien la guardamos en CSV

response.to_csv('IPS.csv')

Implementar GLPI en Docker

 Asumiendo que ya tienes docker-compose instalado, el archivo compose es el siguiente:

version: '3'

services:
  db:
    image: mariadb:10.5
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: example
      MYSQL_DATABASE: glpidb
      MYSQL_USER: glpi
      MYSQL_PASSWORD: example
    volumes:
      - db-data:/var/lib/mysql

  glpi:
    image: glpi/glpi:latest
    restart: always
    ports:
      - "8080:80"
    environment:
      GLPI_DB_HOST: db
      GLPI_DB_NAME: glpidb
      GLPI_DB_USER: glpi
      GLPI_DB_PASSWORD: example
    volumes:
      - glpi-data:/var/www/html/glpi

volumes:
  db-data:
  glpi-data:

Este archivo de Docker Compose crea dos servicios: uno para la base de datos y otro para GLPI. El servicio de la base de datos utiliza la imagen de MariaDB y define las variables de entorno necesarias para crear la base de datos y el usuario.

El servicio GLPI utiliza la imagen oficial de GLPI y expone el puerto 8080 en el host para acceder a la aplicación. Además, utiliza las variables de entorno definidas para conectarse a la base de datos y monta un volumen para almacenar los datos persistentes de GLPI.

Para ejecutar este archivo de Docker Compose, asegúrate de tener Docker y Docker Compose instalados y luego ejecuta el siguiente comando en el directorio donde se encuentra el archivo docker-compose.yml:

 

docker-compose up -d

 

 Esto iniciará los servicios en segundo plano. Puedes acceder a GLPI en tu navegador web en http://localhost:8080

 

Spanning Tree

 

¿Qué es Spanning Tree?

Spanning Tree es un protocolo de red que se utiliza para evitar la formación de bucles de red en topologías de red redundantes. La redundancia es importante en las redes, ya que proporciona tolerancia a fallos y aumenta la disponibilidad de la red. Sin embargo, la redundancia también puede causar problemas, como la formación de bucles de red que pueden afectar negativamente al rendimiento de la red. Spanning Tree es una solución para estos problemas de bucles de red.

¿Cómo funciona Spanning Tree?

Spanning Tree se basa en un algoritmo que selecciona un camino principal entre los dispositivos de red, y bloquea todos los demás caminos redundantes. Este camino principal se llama "árbol de expansión". El algoritmo de Spanning Tree selecciona el camino principal en función de una serie de factores, como la velocidad de la conexión y la distancia. Una vez que se ha seleccionado el camino principal, todos los demás caminos redundantes se bloquean, lo que impide la formación de bucles de red.

Para seleccionar el camino principal y bloquear los caminos redundantes, Spanning Tree utiliza varios mensajes de control de red. Estos mensajes se envían entre los dispositivos de red y se utilizan para detectar y eliminar bucles de red. El algoritmo de Spanning Tree utiliza estos mensajes para construir un árbol de expansión que cubre toda la topología de la red. Una vez que se ha construido el árbol de expansión, se utilizan los mensajes de control para bloquear los caminos redundantes.

¿Por qué es importante Spanning Tree?

Spanning Tree es importante porque evita la formación de bucles de red en topologías de red redundantes. Los bucles de red pueden afectar negativamente al rendimiento de la red, lo que puede causar problemas en el funcionamiento de la red. Spanning Tree asegura que haya un camino principal claro en la red, lo que garantiza que los paquetes de red se transmitan de forma eficiente y segura.

Además, Spanning Tree también proporciona tolerancia a fallos en la red. Si un enlace de red falla, Spanning Tree automáticamente selecciona un nuevo camino principal y desbloquea los caminos redundantes necesarios para garantizar que la red siga funcionando correctamente. Esto significa que si un enlace de red falla, la red puede seguir funcionando sin interrupciones.

En resumen, Spanning Tree es un protocolo de red que evita la formación de bucles de red en topologías de red redundantes. Utiliza un algoritmo que selecciona un camino principal entre los dispositivos de red y bloquea todos los demás caminos redundantes. Spanning Tree es importante porque asegura que haya un camino claro en la red y proporciona tolerancia a fallos.

 

Configuracion basica en Cisco

 

Switch(config)# spanning-tree mode rapid-pvst
Switch(config)# spanning-tree vlan 1-1000 priority 4096
Switch(config)# spanning-tree portfast default
 

 

La primera línea configura el modo de Spanning Tree como "rapid-pvst". Este es un modo de Spanning Tree rápido  por VLAN.

La segunda línea establece la prioridad de Spanning Tree para las VLAN del 1 al 1000 en 4096. Esta es una prioridad baja, lo que significa que este switch  será el puente raíz para esas VLAN, a menos que no haya ningún otro switch con una prioridad aún más baja.

La tercera línea configura el modo "portfast" por defecto en todos los puertos del switch. "Portfast" es una característica que permite que los puertos del switch se conviertan rápidamente en puertos de acceso y eviten los tiempos de espera de Spanning Tree al conectar un dispositivo final a un puerto. Es importante tener en cuenta que no se debe habilitar "portfast" en puertos que se conectan a otros switches o dispositivos que puedan generar bucles en la red.

Es importante tener en cuenta que esta es solo una configuración básica de Spanning Tree y que hay muchas opciones y características adicionales que se pueden configurar para ajustar el comportamiento de Spanning Tree en una red. Se recomienda consultar la documentación de Cisco y trabajar con un profesional de red experimentado para diseñar y configurar una red de Spanning Tree adecuada para sus necesidades.

Servidor web simple para compartir archivos

 Muchas veces necesitamos compartir archivos en dispositivos en la red de manera rapida por http, ejemplo al querer actualizar un dispositivo como telefono o switch. La manera mas rapida, si ya tiene Python, utilizar el siguiente comando:

python3 -m http.server 8080

Con esto ya estaras compartiendo el directorio donde estas ubicado al momento de ejecutar este comando.

Crear ISO de Vyos

 Para crear una ISO de Vyos se dben seguir los siguientes pasos:

Descargar contenedor

Debemos descargar el siguiente contenedor para la version 1.3 de Vyos:

docker pull vyos/vyos-build:equuleus   # For VyOS 1.3

Clonar repositorio

Debemos bajar el siguiente respositorio

git clone -b equuleus --single-branch https://github.com/vyos/vyos-build

Crear contenedor y compilar

Debebos crear el contenedor, ingresar al el y ejecutar la compilacion:

cd vyos-build
docker run --rm -it --privileged -v $(pwd):/vyos -w /vyos vyos/vyos-build:equuleus bash
#dentro del contenedor ejecutat la compilacion
vyos_bld@d4220bb519a0:/vyos# ./configure --architecture amd64 --build-by "cabildo@gmail.com"
vyos_bld@d4220bb519a0:/vyos# sudo make iso

Ya esta creada la imagen

mas informacion Aqui