Linux Basics

Supported Versions: All major Linux distributions (Ubuntu 20.04+, CentOS/RHEL 8+, Debian 11+) Última actualización: February 11, 2026

Comprender los fundamentos de Linux es esencial para entender Kubernetes y la tecnología de contenedores. Este documento cubre los conceptos principales de Linux que son especialmente importantes en entornos Kubernetes.

Lab Environment Setup

Para seguir los ejemplos de este documento, necesitarás el siguiente entorno:

Required Environment

• Sistema operativo Linux (se recomienda Ubuntu 20.04+, CentOS/RHEL 8+, Debian 11+)
• Acceso a la terminal
• Privilegios sudo

Cloud Environment Setup (Optional)

Si usas una instancia AWS EC2:

# Start an Amazon Linux 2 instance
aws ec2 run-instances \
  --image-id ami-0c55b159cbfafe1f0 \
  --instance-type t3.micro \
  --key-name your-key-pair \
  --security-group-ids sg-12345678 \
  --subnet-id subnet-12345678

# SSH connection
ssh -i your-key.pem ec2-user@your-instance-public-ip

Local Environment Setup (Optional)

Para practicar localmente, puedes usar una de las siguientes opciones:

• VirtualBox + Vagrant: Configura un entorno de máquina virtual
• WSL2: Usa un entorno Linux en Windows
• Docker: Practica en un entorno de contenedor

Table of Contents

• Linux Kernel and User Space
• Process Management
• Namespaces
• cgroups (Control Groups)
• File System
• Networking Basics
• Security Context
• systemd and Service Management
• Kernel Parameters and Modules
• System Resource Limits
• Log Management
• DNS and Network Configuration
• Time Synchronization
• Package Management
• Essential Linux Commands
• Container-Related Linux Features

Linux Kernel and User Space

Role of the Kernel

Concepto clave: El kernel de Linux es el núcleo del sistema operativo y actúa como intermediario entre el hardware y el software.

El kernel de Linux es el núcleo del sistema operativo y actúa como intermediario entre el hardware y el software. Sus funciones principales incluyen:

• Gestión de procesos: Creación, planificación y finalización de procesos
• Gestión de memoria: Asignación de memoria virtual y memoria física
• Gestión de dispositivos: Comunicación con dispositivos de hardware
• Interfaz de llamadas al sistema: Proporciona una forma para que los programas del espacio de usuario accedan a los servicios del kernel

User Space

El espacio de usuario es la región de memoria donde se ejecutan las aplicaciones normales. Los programas del espacio de usuario acceden a los servicios del kernel mediante llamadas al sistema.

System Call Examples

System Call	Description	Related Commands
fork()	Create new process	ps, top
exec()	Execute program	bash, sh
open()	Open file	cat, less
read()	Read data from file	cat, grep
write()	Write data to file	echo, tee
socket()	Create network socket	netstat, ss
clone()	Create namespace	unshare, docker

Linux Kernel Architecture

Process Management

Processes and Threads

• Proceso: Una instancia de un programa en ejecución con su propio espacio de memoria independiente
• Thread: Una unidad de trabajo que se ejecuta dentro de un proceso; los threads del mismo proceso comparten el espacio de memoria

Process States

• En ejecución: Se está ejecutando actualmente en la CPU
• En espera: Espera la finalización de E/S o la ocurrencia de un evento
• Listo: Preparado para ejecutarse, pero esperando asignación de CPU
• Zombie: Finalizado, pero el proceso padre no ha comprobado su estado
• Detenido: Estado suspendido

Key Process Management Commands

# View process list
ps aux

# Real-time process monitoring
top

# Enhanced real-time process monitoring
htop

# Terminate process
kill <PID>
killall <process-name>

# Background execution
command &

# Job management
jobs
fg %<job-number>
bg %<job-number>

Namespaces

Los namespaces son una característica del kernel de Linux que aísla grupos de procesos para que cada grupo pueda ver los recursos del sistema de forma independiente. Esto es un elemento central de la tecnología de contenedores.

Main Namespace Types

• PID Namespace: Aislamiento de ID de procesos; permite que los contenedores tengan su propio PID 1 (init)
• Network Namespace: Aislamiento de la pila de red (interfaces, direcciones IP, tablas de enrutamiento, firewalls, etc.); base para la red de contenedores
• Mount Namespace: Aislamiento de puntos de montaje del sistema de archivos; proporciona un sistema de archivos independiente por contenedor
• UTS Namespace: Aislamiento de nombre de host y nombre de dominio; da a cada contenedor un identificador de host único
• IPC Namespace: Aislamiento de recursos de comunicación entre procesos (memoria compartida, semáforos, colas de mensajes, etc.); importante para el aislamiento de servicios en una arquitectura de microservices
• User Namespace: Aislamiento de ID de usuarios y grupos; admite la ejecución de contenedores rootless para mejorar la seguridad
• cgroup Namespace: Aislamiento del directorio raíz de cgroup; proporciona visibilidad de los límites de recursos dentro de los contenedores
• Time Namespace: Aislamiento del reloj del sistema; permite configuraciones de tiempo independientes por contenedor (Linux 5.6+)

Namespace-Related Commands

# Check process namespaces
ls -la /proc/<PID>/ns/

# Execute command in new namespace
unshare --net --pid --fork --mount-proc bash

# Enter existing process's namespace
nsenter --target <PID> --net --pid bash

# Create and manage network namespaces
ip netns add <name>
ip netns exec <name> <command>

# Using user namespace for rootless container execution
unshare --user --map-root-user --mount --net bash

# Using time namespace (Linux 5.6+)
unshare --time bash

cgroups (Control Groups)

cgroups es una característica del kernel de Linux que limita y aísla el uso de recursos de los grupos de procesos. Se usa para implementar límites de recursos de contenedores. Es una tecnología central para la gestión de recursos en entornos cloud-native y Kubernetes.

Main cgroups Features

• Limitación de tiempo de CPU: Limita el tiempo de CPU disponible para grupos de procesos y asigna núcleos de CPU
• Limitación de memoria: Limita la memoria disponible para grupos de procesos y controla el comportamiento OOM (Out of Memory)
• Limitación de E/S de bloques: Limitación del ancho de banda de E/S de disco y configuración de prioridades
• Limitación de ancho de banda de red: Limitación del tráfico de red (combinada con tc)
• Control de acceso a dispositivos: Control de acceso y gestión de permisos para dispositivos específicos
• Control de PIDs: Limita el número de creación de procesos para evitar fork bombs
• Freezer: Pausa y reanuda grupos de procesos (se usa para pausar contenedores)
• cpuset: Vincula procesos a núcleos de CPU y nodos NUMA específicos

cgroups v1 and v2

• cgroups v1: Jerarquía separada para cada tipo de recurso; todavía se usa en sistemas heredados
• cgroups v2: Jerarquía única unificada para una gestión más coherente; predeterminada en distribuciones modernas
• Modo híbrido: Usa v1 y v2 juntos para mantener compatibilidad mientras se aprovechan nuevas características

cgroups-Related Commands

# Check cgroups
ls -la /sys/fs/cgroup/                     # cgroups v2
ls -la /sys/fs/cgroup/cpu /sys/fs/cgroup/memory  # cgroups v1

# cgroups management through systemd (modern approach)
systemctl set-property <service-name> CPUQuota=20%
systemctl set-property <service-name> MemoryLimit=1G
systemctl set-property <service-name> IOWeight=500

# Check process cgroup
cat /proc/<PID>/cgroup

# Direct cgroups v2 manipulation (advanced)
echo $$ > /sys/fs/cgroup/user.slice/cgroup.procs
echo "max 100000" > /sys/fs/cgroup/user.slice/memory.max
echo "100000 500000" > /sys/fs/cgroup/user.slice/memory.high

# Container runtime and cgroups
podman stats  # Monitor container resource usage
docker run --cpus=0.5 --memory=512m nginx  # Set resource limits

File System

File System Hierarchy

Linux tiene una estructura jerárquica de sistema de archivos que empieza desde un único directorio raíz (/).

Directorios clave:

• /bin: Comandos básicos
• /sbin: Comandos de administración del sistema
• /etc: Archivos de configuración del sistema
• /home: Directorios de inicio de usuarios
• /var: Datos variables (logs, caché, etc.)
• /tmp: Archivos temporales
• /usr: Programas y datos de usuario
• /proc: Información de procesos y del kernel (sistema de archivos virtual)
• /sys: Información del sistema y del hardware (sistema de archivos virtual)

File System Types

• ext4: Sistema de archivos Linux predeterminado
• XFS: Adecuado para sistemas de archivos grandes
• Btrfs: Proporciona características avanzadas como snapshots y compresión
• OverlayFS: Representa varios directorios como un único directorio (se usa comúnmente en contenedores)
• tmpfs: Sistema de archivos temporal basado en memoria

Mount and Volumes

# Mount file system
mount -t <filesystem-type> <source> <mount-point>

# Check mounted file systems
mount
df -h

# Unmount file system
umount <mount-point>

Networking Basics

Network Interfaces

• lo: Interfaz loopback (127.0.0.1)
• eth0, ens3, etc.: Interfaces de red físicas
• docker0, cni0, etc.: Interfaces bridge virtuales (red de contenedores)

Network Configuration Commands

# Check network interfaces
ip addr show
ifconfig

# Check routing table
ip route
route -n

# Check network connections
netstat -tuln
ss -tuln

# Network packet analysis
tcpdump -i <interface>

Network Namespaces and Virtual Interfaces

# Create network namespace
ip netns add <namespace-name>

# Create virtual ethernet pair
ip link add <veth1> type veth peer name <veth2>

# Connect virtual interface to namespace
ip link set <veth2> netns <namespace-name>

Security Context

Users and Groups

• UID (User ID): Identificador de usuario
• GID (Group ID): Identificador de grupo
• root (UID 0): Usuario especial con privilegios administrativos

File Permissions

Los permisos de archivos de Linux consisten en permisos de lectura (r), escritura (w) y ejecución (x) para el propietario, el grupo y otros usuarios.

Permission-Related Commands

# Change file permissions
chmod 755 <filename>  # rwxr-xr-x
chmod u+x <filename>  # Add execute permission for owner

# Change file owner
chown <user>:<group> <filename>

# Special permissions
chmod 4755 <filename>  # Set setuid
chmod 2755 <filename>  # Set setgid
chmod 1755 <filename>  # Set sticky bit

SELinux and AppArmor

• SELinux (Security-Enhanced Linux): Sistema de control de acceso obligatorio desarrollado por la NSA
• AppArmor: Sistema de control de acceso que usa perfiles de seguridad por programa

# Check SELinux status
getenforce

# Change SELinux mode
setenforce 0  # Permissive mode
setenforce 1  # Enforcing mode

# Check AppArmor status
aa-status

# AppArmor profile management
aa-enforce /etc/apparmor.d/<profile>
aa-complain /etc/apparmor.d/<profile>

systemd and Service Management

systemd es el sistema init y gestor de servicios para los sistemas Linux modernos. Se usa para gestionar servicios principales como kubelet y containerd en nodos Kubernetes.

Main systemd Features

• Gestión de servicios: Iniciar, detener, reiniciar y habilitar/deshabilitar servicios del sistema
• Gestión de dependencias: Gestión automática de dependencias de servicios e inicio paralelo
• Logging: Gestión integrada de logs mediante journald
• Timers: Unidades de temporizador que pueden reemplazar cron
• Gestión de recursos: Límites de recursos por servicio mediante cgroups

systemd Unit Types

• service: Servicios del sistema (por ejemplo, kubelet.service, containerd.service)
• socket: Activación basada en sockets
• target: Grupos de unidades (similar a runlevels)
• timer: Tareas programadas
• mount: Montajes del sistema de archivos
• device: Unidades de dispositivo

systemd Commands

# Check service status
systemctl status kubelet
systemctl status containerd

# Service control
systemctl start <service>
systemctl stop <service>
systemctl restart <service>
systemctl reload <service>  # Reload configuration

# Set auto-start at boot
systemctl enable <service>
systemctl disable <service>

# Check service logs
journalctl -u kubelet -f  # Real-time logs
journalctl -u kubelet --since "1 hour ago"
journalctl -u kubelet --no-pager

# List all services
systemctl list-units --type=service
systemctl list-unit-files --type=service

# Check failed services
systemctl --failed

# Reload systemd configuration
systemctl daemon-reload

Writing systemd Unit Files

Archivo de unidad systemd de ejemplo para servicios relacionados con Kubernetes:

# /etc/systemd/system/kubelet.service
[Unit]
Description=kubelet: The Kubernetes Node Agent
Documentation=https://kubernetes.io/docs/
Wants=network-online.target
After=network-online.target

[Service]
ExecStart=/usr/bin/kubelet
Restart=always
StartLimitInterval=0
RestartSec=10

[Install]
WantedBy=multi-user.target

systemd Resource Limits

# CPU limit (20%)
systemctl set-property kubelet CPUQuota=20%

# Memory limit (1GB)
systemctl set-property kubelet MemoryLimit=1G

# I/O weight setting (100-1000, default 100)
systemctl set-property kubelet IOWeight=500

# Check settings
systemctl show kubelet | grep -E 'CPUQuota|MemoryLimit|IOWeight'

Kernel Parameters and Modules

Kernel Parameter Settings via sysctl

sysctl es una herramienta para consultar y modificar parámetros del kernel en ejecución. Es esencial para ajustar parámetros de red y del sistema al configurar clusters Kubernetes.

Key sysctl Settings Required for Kubernetes

# Enable IP forwarding (required for container networking)
sysctl -w net.ipv4.ip_forward=1
sysctl -w net.ipv6.conf.all.forwarding=1

# Enable bridge traffic to pass through iptables (required for CNI plugins)
sysctl -w net.bridge.bridge-nf-call-iptables=1
sysctl -w net.bridge.bridge-nf-call-ip6tables=1

# Increase maximum file descriptor count
sysctl -w fs.file-max=2097152

# Network performance tuning
sysctl -w net.core.somaxconn=32768
sysctl -w net.ipv4.tcp_max_syn_backlog=8192
sysctl -w net.core.netdev_max_backlog=16384

# ARP cache settings (for large clusters)
sysctl -w net.ipv4.neigh.default.gc_thresh1=80000
sysctl -w net.ipv4.neigh.default.gc_thresh2=90000
sysctl -w net.ipv4.neigh.default.gc_thresh3=100000

# Check current settings
sysctl net.ipv4.ip_forward
sysctl -a | grep bridge-nf-call

# Persistent settings (/etc/sysctl.conf or /etc/sysctl.d/*.conf)
cat <<EOF | sudo tee /etc/sysctl.d/99-kubernetes.conf
net.ipv4.ip_forward = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
EOF

# Apply settings
sysctl --system

Kernel Module Management

Muchos plugins CNI y controladores de almacenamiento requieren módulos específicos del kernel.

# Load modules
modprobe overlay  # OverlayFS (container storage)
modprobe br_netfilter  # Bridge networking
modprobe ip_vs  # IPVS load balancing (kube-proxy IPVS mode)
modprobe ip_vs_rr  # Round Robin algorithm
modprobe ip_vs_wrr  # Weighted Round Robin
modprobe ip_vs_sh  # Source Hashing

# Check loaded modules
lsmod | grep overlay
lsmod | grep br_netfilter

# Check module information
modinfo overlay

# Set auto-load at boot
cat <<EOF | sudo tee /etc/modules-load.d/kubernetes.conf
overlay
br_netfilter
ip_vs
ip_vs_rr
ip_vs_wrr
ip_vs_sh
EOF

# Unload module
modprobe -r <module-name>

Kernel Version and Feature Check

# Check kernel version
uname -r

# Check kernel compile options
cat /boot/config-$(uname -r) | grep OVERLAY
cat /boot/config-$(uname -r) | grep NETFILTER

# Check available kernel features
cat /proc/filesystems  # Supported file systems
cat /proc/sys/net/ipv4/ip_forward  # IP forwarding status

System Resource Limits

ulimit - Per-User Resource Limits

ulimit limita los recursos del sistema que pueden usar los procesos. Es posible que se necesiten ajustes en nodos Kubernetes para garantizar recursos suficientes.

# Check current limits
ulimit -a

# Key limit items
ulimit -n      # Number of open file descriptors
ulimit -u      # Maximum number of processes
ulimit -m      # Maximum memory size
ulimit -v      # Virtual memory size

# Change limits (current session)
ulimit -n 65536  # Increase file descriptors to 65536

# Persistent settings (/etc/security/limits.conf)
sudo tee -a /etc/security/limits.conf <<EOF
*               soft    nofile          65536
*               hard    nofile          65536
*               soft    nproc           32768
*               hard    nproc           32768
EOF

# Settings for specific users/groups
sudo tee -a /etc/security/limits.conf <<EOF
root            soft    nofile          65536
root            hard    nofile          65536
@docker         soft    nofile          65536
@docker         hard    nofile          65536
EOF

PAM Limit Settings

# Check PAM settings
cat /etc/pam.d/common-session
cat /etc/pam.d/common-session-noninteractive

# Add to PAM settings to apply limits.conf
echo "session required pam_limits.so" | sudo tee -a /etc/pam.d/common-session

Per-Process Resource Checking

# Check current resource limits for a process
cat /proc/<PID>/limits

# Check file descriptors for a specific process
ls -l /proc/<PID>/fd | wc -l

Log Management

journald - systemd Integrated Logging

journald es el sistema de logging de systemd que gestiona logs de servicios del sistema en nodos Kubernetes.

# Full system logs
journalctl

# Specific service logs
journalctl -u kubelet
journalctl -u containerd
journalctl -u docker

# Real-time logs (similar to tail -f)
journalctl -u kubelet -f

# Time range specification
journalctl --since "2025-11-24 10:00:00"
journalctl --since "1 hour ago"
journalctl --since yesterday
journalctl --until "2025-11-24 12:00:00"

# Filter by priority
journalctl -p err        # Errors only
journalctl -p warning    # Warnings and above
journalctl -p debug      # All including debug

# Change output format
journalctl -u kubelet -o json        # JSON format
journalctl -u kubelet -o json-pretty # Pretty JSON
journalctl -u kubelet -o cat         # Messages only

# Boot logs
journalctl -b           # Current boot logs
journalctl -b -1        # Previous boot logs
journalctl --list-boots # Boot list

# Check disk usage
journalctl --disk-usage

# Clean logs
journalctl --vacuum-time=7d   # Delete logs older than 7 days
journalctl --vacuum-size=1G   # Delete logs over 1GB

journald Configuration

# journald configuration file
sudo vi /etc/systemd/journald.conf

# Key configuration options
# Storage=persistent        # Persistent storage to disk
# SystemMaxUse=1G          # Maximum disk usage
# SystemKeepFree=500M      # Minimum free space
# MaxRetentionSec=1month   # Maximum retention period

# Apply configuration
sudo systemctl restart systemd-journald

Traditional syslog

Algunos sistemas todavía usan syslog.

# syslog file locations
/var/log/syslog         # Debian/Ubuntu
/var/log/messages       # RHEL/CentOS

# Real-time log viewing
tail -f /var/log/syslog

# Log search
grep "kubelet" /var/log/syslog
grep -i "error" /var/log/syslog

Log Rotation

Configura la rotación de logs para evitar que los archivos de log crezcan indefinidamente.

# logrotate configuration
sudo vi /etc/logrotate.d/kubernetes

# Example configuration
/var/log/kubernetes/*.log {
    daily
    rotate 7
    missingok
    notifempty
    compress
    delaycompress
    copytruncate
}

# Run rotation manually
sudo logrotate -f /etc/logrotate.d/kubernetes

DNS and Network Configuration

DNS Configuration

DNS es fundamental para el descubrimiento de servicios dentro de clusters Kubernetes.

# DNS configuration file
cat /etc/resolv.conf

# Example configuration
nameserver 8.8.8.8
nameserver 8.8.4.4
search cluster.local svc.cluster.local
options ndots:5

# DNS lookup test
nslookup kubernetes.default.svc.cluster.local
dig kubernetes.default.svc.cluster.local

# hosts file
cat /etc/hosts

systemd-resolved

Las distribuciones Linux modernas usan systemd-resolved.

# Check systemd-resolved status
systemctl status systemd-resolved

# Check DNS servers
resolvectl status

# DNS cache statistics
resolvectl statistics

# Clear DNS cache
resolvectl flush-caches

Network Configuration Files

# NetworkManager (RHEL/CentOS 8+, Ubuntu 18.04+)
nmcli connection show
nmcli device status

# netplan (Ubuntu 18.04+)
cat /etc/netplan/*.yaml

# Example netplan configuration
network:
  version: 2
  ethernets:
    eth0:
      dhcp4: true
      nameservers:
        addresses: [8.8.8.8, 8.8.4.4]

# Apply configuration
sudo netplan apply

Time Synchronization

La sincronización de tiempo es muy importante en sistemas distribuidos. Todos los nodos de un cluster Kubernetes deben mantener una hora precisa.

chronyd (Recommended)

chronyd es un cliente NTP moderno que sincroniza la hora más rápido que ntpd.

# Install chronyd (RHEL/CentOS)
sudo yum install chrony

# Install chronyd (Ubuntu/Debian)
sudo apt install chrony

# Check service status
systemctl status chronyd

# Check time synchronization status
chronyc tracking

# NTP server list
chronyc sources

# Detailed information
chronyc sourcestats

# Manual time synchronization
sudo chronyc makestep

chronyd Configuration

# Configuration file
sudo vi /etc/chrony.conf

# Key settings
# NTP server configuration
server 0.pool.ntp.org iburst
server 1.pool.ntp.org iburst
server 2.pool.ntp.org iburst
server 3.pool.ntp.org iburst

# Fast synchronization
makestep 1.0 3

# Apply configuration
sudo systemctl restart chronyd

timesyncd (Ubuntu Default)

Ubuntu usa systemd-timesyncd de forma predeterminada.

# Check status
timedatectl status

# NTP synchronization status
timedatectl show-timesync --all

# Configuration file
sudo vi /etc/systemd/timesyncd.conf

# Example configuration
[Time]
NTP=0.pool.ntp.org 1.pool.ntp.org
FallbackNTP=time.google.com

# Restart service
sudo systemctl restart systemd-timesyncd

Timezone Settings

# Check current time and timezone
timedatectl

# List timezones
timedatectl list-timezones

# Change timezone
sudo timedatectl set-timezone Asia/Seoul

# Manually set time (when NTP is disabled)
sudo timedatectl set-time "2025-11-24 12:00:00"

# Enable/disable NTP
sudo timedatectl set-ntp true

Package Management

Uso del gestor de paquetes para instalar y gestionar Kubernetes y herramientas relacionadas.

apt (Debian/Ubuntu)

# Update package list
sudo apt update

# Upgrade packages
sudo apt upgrade

# Install package
sudo apt install <package-name>

# Remove package
sudo apt remove <package-name>
sudo apt purge <package-name>  # Remove configuration files as well

# Search packages
apt search <keyword>

# Package information
apt show <package-name>

# List installed packages
apt list --installed

# Add repository (Kubernetes example)
sudo apt install -y apt-transport-https ca-certificates curl
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | \
  sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] \
  https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | \
  sudo tee /etc/apt/sources.list.d/kubernetes.list

# Clean unnecessary packages
sudo apt autoremove
sudo apt autoclean

yum/dnf (RHEL/CentOS/Fedora)

# Install package
sudo yum install <package-name>
sudo dnf install <package-name>  # Fedora/RHEL 8+

# Update packages
sudo yum update
sudo dnf update

# Remove package
sudo yum remove <package-name>
sudo dnf remove <package-name>

# Search packages
yum search <keyword>
dnf search <keyword>

# Package information
yum info <package-name>
dnf info <package-name>

# List installed packages
yum list installed
dnf list installed

# Add repository (Kubernetes example)
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.28/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.28/rpm/repodata/repomd.xml.key
EOF

# Clean cache
sudo yum clean all
sudo dnf clean all

Package Version Locking

Los componentes de Kubernetes tienen requisitos de compatibilidad de versiones, por lo que se deben evitar las actualizaciones automáticas.

# apt (Ubuntu/Debian)
sudo apt-mark hold kubelet kubeadm kubectl

# Remove apt hold
sudo apt-mark unhold kubelet kubeadm kubectl

# yum (RHEL/CentOS)
sudo yum install yum-plugin-versionlock
sudo yum versionlock add kubelet kubeadm kubectl

# Remove yum versionlock
sudo yum versionlock delete kubelet kubeadm kubectl

Essential Linux Commands

File and Directory Management

ls -la           # List files (including hidden)
cd <directory>   # Change directory
pwd              # Print current directory
mkdir -p <path>  # Create directory (create parent directories if needed)
rm -rf <path>    # Remove files/directories
cp -r <source> <destination> # Copy files/directories
mv <source> <destination>    # Move or rename files/directories
find <path> -name "<pattern>" # Search files

Text Processing

cat <file>        # Output file contents
less <file>       # View file contents page by page
grep "<pattern>" <file> # Search pattern in file
sed 's/<pattern>/<replacement>/' <file> # Text substitution
awk '{print $1}' <file> # Text processing

System Information

uname -a         # Kernel information
lsb_release -a   # Distribution information
free -h          # Memory usage
df -h            # Disk usage
du -sh <path>    # Directory size

Process and Service Management

systemctl status <service> # Check service status
systemctl start/stop/restart <service> # Service control
journalctl -u <service> # View service logs

Container-Related Linux Features

OverlayFS

OverlayFS es un sistema de archivos de montaje union que representa varios directorios como un único directorio. Lo usan runtimes de contenedores como Docker para implementar capas de imágenes.

Network Bridge and NAT

La red de contenedores se implementa principalmente mediante interfaces bridge y NAT (Network Address Translation).

System Call Filtering (seccomp)

seccomp (Secure Computing Mode) es una característica del kernel de Linux que restringe las llamadas al sistema disponibles para los procesos. Se usa para mejorar la seguridad de los contenedores.

Capabilities Restriction

Las capabilities de Linux dividen los privilegios tradicionales de root en unidades de permisos más pequeñas. Los contenedores reciben solo las capabilities necesarias para mejorar la seguridad.

Capabilities clave:

• CAP_NET_ADMIN: Cambios en la configuración de red
• CAP_SYS_ADMIN: Tareas de administración del sistema
• CAP_CHOWN: Cambiar la propiedad de archivos
• CAP_DAC_OVERRIDE: Omitir permisos de archivos

Conclusion

Los fundamentos y características de Linux son esenciales para comprender Kubernetes y la tecnología de contenedores. Aquí tienes un resumen de los temas clave cubiertos en este documento:

Core Technologies

• Namespaces y cgroups: Base para el aislamiento y la gestión de recursos de contenedores
• OverlayFS: Núcleo de las capas de imágenes de contenedores
• systemd: Gestión de servicios de nodos Kubernetes

Essential Operations Knowledge

• Ajuste de parámetros del kernel: Optimización de red y sistema mediante sysctl
• Gestión de módulos: Soporte para plugins CNI y controladores de almacenamiento
• Gestión de logs: Análisis de logs del sistema y de servicios mediante journald
• Sincronización de tiempo: Mantener la coherencia en sistemas distribuidos

Troubleshooting

• Límites de recursos: Gestión de recursos mediante ulimit y cgroups
• Redes: Configuración de DNS, bridge e iptables
• Gestión de paquetes: Gestión de versiones de componentes de Kubernetes

Con esta base de Linux, puedes solucionar eficazmente problemas en entornos Kubernetes, optimizar clusters y operarlos de forma fiable.

Quiz

Para comprobar lo que has aprendido en este capítulo, realiza el Linux Basics Quiz.

References

• The Linux Documentation Project
• Linux Kernel Documentation
• Linux Namespaces
• Control Groups v2