rengtech

Winboat: Windows dentro de Docker para Linux

2026-03-31T00:00:00-06:00

Muy buenas tardes a todos y bienvenidos a otro vídeo para el canal. Hoy vamos a tratar el mayor problema que tenemos cuando queremos dar el salto a Linux o cuando ya estamos aquí y nos topamos con el muro del software privativo de Windows. Todos hemos pasado por ahí: te gusta el rendimiento de tu distro —en mi caso ya sabéis que le estoy dando caña a CachyOS—, pero de repente necesitas ese Excel con macros complejas, el Photoshop para algo puntual, o cualquier herramienta de ingeniería que solo corre en .exe.

¿Qué opciones tenemos? Pues hasta ahora era o pelearse con Wine y sus dependencias, o montar una máquina virtual pesada en VirtualBox que se come los recursos y te deja el PC tiritando. Pero hoy os traigo algo que funciona de una forma mucho más eficiente. Se llama Winboat, y básicamente es Windows ejecutándose dentro de Docker de una forma tan optimizada que el rendimiento es sorprendente.

Qué es Winboat y cómo funciona

Lo primero que hay que entender es que Winboat no es una virtualización tradicional al uso. Si habéis usado VirtualBox o VMware, sabéis que el despliegue es un coñazo: descargar la ISO, configurar la BIOS virtual, instalar todo desde cero... es un proceso que se hace eterno. Winboat rompe con eso porque utiliza contenedores de Docker, o Podman si preferís, para levantar una instancia de Windows 11 Pro ya optimizada. Es lo que llamamos Windows inside Docker.

Al usar una imagen ya preparada, te ahorras toda la parte aburrida de la instalación. La aplicación levanta el contenedor y, en cuestión de segundos, ya tienes un Windows 11 funcional.

Requisitos y configuración inicial

Para que esto funcione bien, solo necesitáis un par de cosas básicas:

Virtualización habilitada en la BIOS: si no tenéis eso, ninguna herramienta de este tipo va a tirar.
Docker instalado y configurado en vuestra distro.

Una vez que lanzáis Winboat, la interfaz de configuración es súper directa, no tiene pérdida. Podéis asignar los núcleos de CPU que queréis, la RAM —os recomiendo al menos 8 GB si vais a usar Office pesado— y el espacio en disco. Lo bueno es que estos cambios se pueden ajustar después si veis que os habéis quedado cortos.

Passthrough USB y hardware serial

Aquí es donde Winboat destaca, porque uno de los mayores dolores de cabeza en Linux es trabajar con hardware que solo tiene drivers para Windows. Hablo de programadores de Arduino o sistemas que usen comunicación serial USB. A veces, pasar un puerto USB a una máquina virtual tradicional es una lotería: que si no lo reconoce, que si la latencia es demasiado alta...

En Winboat el passthrough de dispositivos USB es sólido. Simplemente conectas el dispositivo, lo mapeas en la configuración de Winboat y listo. La comunicación serial funciona a la primera, lo que lo convierte en una herramienta de trabajo real para no perder el tiempo.

Integración de aplicaciones en el escritorio de Linux

Lo que realmente es interesante es la integración de las aplicaciones. No hace falta que estéis viendo el escritorio de Windows 11 con su barra de tareas si no queréis. Winboat utiliza un renderizado RDP de baja latencia que es totalmente transparente para el usuario. Podéis abrir Microsoft Excel o Photoshop, y la ventana aparecerá en vuestro escritorio de Linux como si fuera una aplicación más.

Se integra con vuestro gestor de ventanas: podéis moverla y redimensionarla igual que haríais con vuestra terminal. La experiencia es fluida, no sientes que estás dentro de una máquina virtual, parece que tienes las aplicaciones nativas en Linux.

Esto es un punto clave comparado con herramientas como WinApps, que está bien pero la configuración es bastante más manual y a veces falla. Winboat simplifica esto para que no tengáis que preocuparos de lo que pasa en segundo plano.

Limitaciones actuales: sin GPU Passthrough

Ahora bien, no todo es perfecto y aquí es donde quiero que prestéis atención. A día de hoy, Winboat en la versión que estoy probando, la 0.8.7 beta, no tiene soporte para GPU Passthrough. ¿Qué significa esto? Pues que no tenéis aceleración gráfica por hardware.

Si vuestra intención es instalar Winboat para jugar a títulos pesados o para hacer edición de vídeo 4K en Premiere, esta no es la herramienta. Para eso sigue siendo mejor una máquina virtual con KVM y una tarjeta dedicada.

Pero para tareas intensivas de CPU, el rendimiento es espectacular. No hay latencia, el ratón se mueve fluido y las aplicaciones responden al instante. Incluso OneDrive, que suele dar problemas en Linux, aquí funciona sin complicaciones: puedes tener tus archivos sincronizados en segundo plano dentro del contenedor y listo.

Por qué tiene sentido usar Winboat

Al final, esto vuelve a lo que siempre buscamos: eficiencia y control. Usar Winboat es una forma de aislar a Windows en un contenedor para que no ensucie nuestro sistema principal. No tienes telemetría de Microsoft corriendo directamente en tu kernel ni actualizaciones forzosas que te cortan el ritmo de trabajo. Tienes un entorno controlado que puedes borrar o recrear en segundos si algo sale mal.

Es una solución técnica elegante para un problema recurrente: aprovechar la potencia de Docker para facilitarnos la vida a los que usamos Linux pero que, por trabajo o necesidad, dependemos de un par de herramientas de Microsoft.

En definitiva, Winboat es la forma más sencilla y estable que he probado de tener aplicaciones de Windows en Linux sin complicaciones. Si estáis cansados de que Wine os dé errores o de que VirtualBox os consuma demasiados recursos, dadle una oportunidad porque funciona realmente bien.

Si os ha gustado el vídeo, dejádmelo abajo en los comentarios. No olvidéis suscribiros para más contenido sobre Linux y herramientas brutales como esta. ¡Hasta luego!

Por qué elegir Debian sobre Ubuntu

2025-02-16T00:00:00-06:00

Muy buenas a todos y bienvenidos. Hoy hablamos de un tema que puede generar mucho debate: Debian o Ubuntu. Si estás pensando en dar el salto a Linux o llevas tiempo usando distribuciones Linux y buscas una experiencia más pura, quédate: te doy varias razones por las que Debian, en mi opinión, le da mil vueltas a Ubuntu.

Todos sabemos que Ubuntu es la distribución de entrada de muchos usuarios al mundo de Linux: es fácil, intuitiva y tiene una gran comunidad detrás. Pero ¿a qué coste? Últimamente usar Ubuntu se siente como utilizar Windows 11 o Android en Linux. Canonical, la empresa detrás de Ubuntu, ha tomado un camino muy comercial y eso se nota. Te meten los snaps por los ojos aunque no los quieras. ¿Quieres utilizar Flatpak? Puedes, pero no viene habilitado por defecto; por defecto van a snaps. Y no olvidemos la telemetría, que parece sacada de Windows 10 o 11 al estilo Microsoft. ¿De verdad queremos escapar de Windows para meternos en algo parecido pero en Linux?

Si buscas libertad y control, aquí van cinco razones para elegir Debian sobre Ubuntu.

1. Olvídate de las imposiciones

En Debian ya no tienes una empresa forzándote a usar su tecnología. No hay snaps obligatorios, no hay telemetría extraña, no hay pop-ups constantes de "pásate a Ubuntu Pro". Debian es una distribución 100% libre y de la comunidad. Tú tienes el control total.

2. Estabilidad

Tienes una distribución con una estabilidad legendaria. ¿Cansado de que una actualización te rompa paquetes del sistema, de que te llenen los mismos apt para instalar paquetes o de que te rompa cualquier tipo de compatibilidad? Debian es famoso por su estabilidad. Sus paquetes no son los más nuevos —están bastante atrasados—, pero están probados hasta la saciedad. Son versiones más antiguas, pero con la garantía de que van a funcionar al 100%. No es como Ubuntu LTS u otras donde cualquier actualización te puede romper algo. Con Debian tu sistema simplemente va a funcionar. Puede ser una distribución más "aburrida" en cuanto a novedades, pero es un sistema en el que puedes confiar para trabajar sin problemas, sabiendo que siempre va a arrancar y funcionar correctamente.

3. Minimalismo y personalización real

Ubuntu viene cargado de software que probablemente nunca vas a utilizar: consume recursos y espacio. Eso en inglés se llama bloatware. Debian en cambio te da una base limpia, un lienzo en blanco. ¿Quieres un entorno de escritorio? Elige el que quieras. ¿Quieres construir tu sistema personalizado a tu gusto? Adelante. No tienes bloatware ni añadidos innecesarios: tienes los entornos de escritorio tal como los han hecho los desarrolladores, sin customización impuesta. Tú tienes la base de ese entorno (por ejemplo GNOME, Cinnamon, MATE o el que quieras) y puedes hacer lo que quieras sobre ello. En Ubuntu tienes la customización de GNOME hecha por Canonical; en Debian instalas GNOME y tienes GNOME por defecto, y haces con él lo que tú quieras.

4. Actualizaciones cuando tú quieras

Ubuntu te obliga a un ritmo de actualizaciones cada seis meses (abril y octubre): versiones nuevas con paquetes actualizados, etc. Con Debian el ciclo es más relajado: una nueva versión estable cada aproximadamente dos años y actualizaciones de mantenimiento. Eso te da una tranquilidad increíble; no tienes que estar constantemente preocupado por la siguiente gran actualización.

5. La base de todo

¿Sabías que Ubuntu está basado en Debian? Es un Debian con customización, software extra y demás hecho por Canonical. Entonces, ¿para qué usar algo tocado por una empresa cuando no aporta gran cosa? Si quieres la base, puedes usar la base y hacer con ella lo que tú quieras. ¿Por qué usar la copia modificada y comercial de Canonical cuando puedes usar la fuente? Usar Debian es entender verdaderamente la filosofía de Linux: libertad, control y una comunidad que ayuda a construir algo entre todos.

Y ojo: no estoy diciendo que Ubuntu sea una distribución horrible que no haya que tocar. Es una distribución que, al igual que Linux Mint u otras, está bien para empezar e introducirte en Linux. Pero si llevas un cierto tiempo en este mundo, has probado varias distribuciones y te molesta el enfoque tipo Microsoft de Canonical, dale una oportunidad a Debian. Si Debian no te convence, hay otras alternativas fantásticas: más fáciles como Linux Mint (también basada en Debian) con un enfoque muy amigable, o si quieres algo más avanzado tienes Fedora, openSUSE, Arch Linux (que ni siquiera es tan difícil de instalar actualmente con el script de instalación). Hay muchas distribuciones más allá de la realizada por Canonical.

En resumen: si buscas estabilidad, control y una experiencia 100% libre, Debian es una distribución muy interesante y la elección lógica si has probado Ubuntu o cualquier redistribución basada en Ubuntu y quieres pasar a una distribución de comunidad. Déjame saber en los comentarios qué opinas: si Ubuntu te parece bien, si crees que Debian está mejor o qué distribución usas. Nos vemos en el siguiente artículo. Hasta luego.

Web Server Setup: Nginx and Apache

2025-01-28T00:00:00-06:00

Web servers are fundamental to hosting applications. Learn to configure and manage them effectively.

Nginx

Installation

apt install nginx        # Debian/Ubuntu
dnf install nginx       # Red Hat
pacman -S nginx          # Arch

Basic Configuration

server {
    listen 80;
    server_name example.com;
    root /var/www/html;
    index index.html;

    location / {
        try_files $uri $uri/ =404;
    }
}

Configuration Files

/etc/nginx/nginx.conf           # Main config
/etc/nginx/sites-available/     # Available sites
/etc/nginx/sites-enabled/       # Enabled sites

Management

nginx -t                # Test configuration
systemctl reload nginx  # Reload config
systemctl restart nginx # Restart server

Apache

Installation

apt install apache2     # Debian/Ubuntu
dnf install httpd      # Red Hat

Virtual Hosts

<VirtualHost *:80>
    ServerName example.com
    DocumentRoot /var/www/html
    <Directory /var/www/html>
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Management

apache2ctl configtest   # Test config
systemctl reload apache2
a2ensite site.conf      # Enable site
a2dissite site.conf     # Disable site

Reverse Proxy

Nginx as reverse proxy:

location / {
    proxy_pass http://localhost:3000;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
}

Static File Serving

location /static/ {
    alias /var/www/static/;
    expires 30d;
    add_header Cache-Control "public, immutable";
}

Logs

# Nginx
tail -f /var/log/nginx/access.log
tail -f /var/log/nginx/error.log

# Apache
tail -f /var/log/apache2/access.log
tail -f /var/log/apache2/error.log

Performance Tuning

Enable gzip compression
Use caching headers
Optimize worker processes
Monitor connection limits

Web servers are the gateway to your applications.

Text Processing with grep, sed, and awk

2025-01-27T00:00:00-06:00

Linux provides powerful tools for processing text. Master these, and you can manipulate data with incredible efficiency.

grep - Pattern Matching

grep searches for patterns in text:

grep "error" logfile.txt
grep -r "pattern" /path/to/dir    # Recursive search
grep -i "case" file.txt            # Case insensitive
grep -v "exclude" file.txt         # Invert match

sed - Stream Editor

sed performs text transformations:

sed 's/old/new/g' file.txt         # Replace all occurrences
sed -n '5,10p' file.txt             # Print lines 5-10
sed '/pattern/d' file.txt           # Delete matching lines

awk - Pattern Processing

awk is a programming language for text processing:

awk '{print $1}' file.txt          # Print first field
awk -F: '{print $1}' /etc/passwd   # Use colon as delimiter
awk '$3 > 1000 {print $1}' file    # Conditional printing

Combining Tools

The real power comes from combining these tools:

# Find all error lines, extract timestamps, count occurrences
grep "ERROR" app.log | awk '{print $1}' | sort | uniq -c

# Replace IP addresses in config files
sed -i 's/192\.168\.1\.1/10.0.0.1/g' *.conf

Practical Examples

# Extract email addresses from a file
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' file.txt

# Count lines in all Python files
find . -name "*.py" -exec wc -l {} + | awk '{sum+=$1} END {print sum}'

These tools form the foundation of command-line text processing. Practice combining them!

System Services and systemd

2025-01-26T00:00:00-06:00

Modern Linux distributions use systemd as the init system and service manager. Understanding it is essential for system administration.

Service Management

systemctl start service      # Start service
systemctl stop service       # Stop service
systemctl restart service    # Restart service
systemctl reload service     # Reload configuration
systemctl status service     # Check status

Service States

systemctl enable service     # Enable on boot
systemctl disable service    # Disable on boot
systemctl is-enabled service # Check if enabled
systemctl is-active service  # Check if running

Viewing Services

systemctl list-units         # All units
systemctl list-units --type=service  # Only services
systemctl list-unit-files    # All unit files

Service Files

Service files are located in: - /etc/systemd/system/ - System services - /usr/lib/systemd/system/ - Package-installed services - ~/.config/systemd/user/ - User services

Example Service File

[Unit]
Description=My Custom Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/myprogram
Restart=always

[Install]
WantedBy=multi-user.target

Logs with journalctl

journalctl -u service         # Service logs
journalctl -f                 # Follow logs
journalctl --since today      # Since today
journalctl -p err             # Error level only

Timers (Cron Alternative)

systemctl list-timers         # List all timers
systemctl status timer        # Timer status

systemd provides a unified interface for managing system services and resources.

System Monitoring and Performance

2025-01-25T00:00:00-06:00

Monitoring system resources helps you understand performance and identify bottlenecks before they become problems.

CPU Monitoring

top                    # Interactive CPU/memory viewer
htop                   # Enhanced version
vmstat 1               # Virtual memory stats
mpstat 1               # CPU statistics

Memory Monitoring

free -h                # Memory usage
cat /proc/meminfo      # Detailed memory info
ps aux --sort=-%mem    # Processes by memory

Disk I/O

iostat -x 1            # I/O statistics
iotop                  # I/O by process
df -h                  # Disk space
du -sh *               # Directory sizes

Network Monitoring

netstat -tulpn         # Network connections
ss -tulpn              # Modern alternative
iftop                  # Network traffic by host
nethogs                # Network by process

System Load

uptime                 # Load averages
w                      # Who and load
cat /proc/loadavg      # Load averages

Process Monitoring

ps aux --sort=-%cpu    # By CPU usage
ps aux --sort=-%mem    # By memory
pgrep -f pattern       # Find process IDs

Continuous Monitoring

# Watch command
watch -n 1 'df -h'

# Custom monitoring script
while true; do
    echo "$(date): $(free -h | grep Mem)"
    sleep 5
done

Performance Tuning

Identify resource bottlenecks
Optimize based on monitoring data
Set up alerts for thresholds
Document baseline performance

Regular monitoring helps maintain system health and performance.

System Automation with Cron and systemd Timers

2025-01-24T00:00:00-06:00

Automation is key to efficient system administration. Linux provides multiple tools for scheduling and automating tasks.

Cron - Traditional Scheduler

Crontab Format

* * * * * command
│ │ │ │ │
│ │ │ │ └─── Day of week (0-7, Sunday = 0 or 7)
│ │ │ └───── Month (1-12)
│ │ └─────── Day of month (1-31)
│ └───────── Hour (0-23)
└─────────── Minute (0-59)

Examples

# Edit crontab
crontab -e

# Examples
0 2 * * * /path/to/backup.sh        # Daily at 2 AM
*/15 * * * * /path/to/check.sh      # Every 15 minutes
0 0 1 * * /path/to/monthly.sh       # First day of month

Special Strings

@reboot    # Run at boot
@daily     # Once per day
@weekly    # Once per week
@monthly   # Once per month
@yearly    # Once per year

systemd Timers

Modern alternative to cron with better logging and dependencies:

Timer File

[Unit]
Description=Daily Backup Timer

[Timer]
OnCalendar=daily
OnBootSec=10min

[Install]
WantedBy=timers.target

Service File

[Unit]
Description=Daily Backup Service

[Service]
Type=oneshot
ExecStart=/path/to/backup.sh

Management

systemctl enable --now backup.timer
systemctl list-timers
systemctl status backup.timer

Ansible for Automation

For complex automation across multiple systems:

- name: Update packages
  apt:
    update_cache: yes
    upgrade: dist
  become: yes

Best Practices

Test scripts before scheduling
Log all automated tasks
Use systemd timers for new systems
Document what each automation does
Set up monitoring for automated tasks

Automation reduces manual work and ensures consistency across systems.

SSL/TLS Certificates with Let's Encrypt

2025-01-23T00:00:00-06:00

SSL/TLS certificates encrypt web traffic. Let's Encrypt provides free certificates with automated renewal.

Certbot Installation

apt install certbot python3-certbot-nginx    # Nginx
apt install certbot python3-certbot-apache   # Apache

Obtaining Certificates

Nginx

certbot --nginx -d example.com -d www.example.com

Apache

certbot --apache -d example.com -d www.example.com

Standalone (Manual)

certbot certonly --standalone -d example.com

Certificate Files

/etc/letsencrypt/live/example.com/
├── cert.pem          # Certificate
├── chain.pem         # Chain
├── fullchain.pem     # Full chain
└── privkey.pem       # Private key

Nginx SSL Configuration

server {
    listen 443 ssl http2;
    server_name example.com;

    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
}

HTTP to HTTPS Redirect

server {
    listen 80;
    server_name example.com;
    return 301 https://$server_name$request_uri;
}

Auto-Renewal

# Test renewal
certbot renew --dry-run

# Manual renewal
certbot renew

# Automatic renewal (systemd timer)
systemctl enable certbot.timer

Wildcard Certificates

certbot certonly --manual --preferred-challenges dns -d *.example.com

Certificate Information

openssl x509 -in cert.pem -text -noout
certbot certificates

Best Practices

Enable auto-renewal
Use strong ciphers
Redirect HTTP to HTTPS
Monitor certificate expiration
Test renewal process

SSL/TLS is essential for secure web communication.

Shell Scripting Fundamentals

2025-01-22T00:00:00-06:00

Shell scripts automate repetitive tasks and combine commands into powerful workflows.

Basic Script Structure

#!/bin/bash
# This is a comment

echo "Hello, World!"

Make it executable: chmod +x script.sh

Variables

NAME="Linux"
echo "Welcome to $NAME"
echo "Current directory: $(pwd)"

Control Structures

Conditionals

if [ condition ]; then
    commands
elif [ condition ]; then
    commands
else
    commands
fi

Loops

# For loop
for file in *.txt; do
    echo "Processing $file"
done

# While loop
while [ condition ]; do
    commands
done

Functions

function greet() {
    echo "Hello, $1"
}

greet "World"

Input and Arguments

# Read from user
read -p "Enter name: " name

# Command-line arguments
echo "First argument: $1"
echo "All arguments: $@"
echo "Number of arguments: $#"

Error Handling

set -e              # Exit on error
set -u              # Exit on undefined variable
set -o pipefail     # Catch errors in pipes

Practical Example

#!/bin/bash
# Backup script

BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d)

if [ ! -d "$BACKUP_DIR" ]; then
    mkdir -p "$BACKUP_DIR"
fi

tar -czf "$BACKUP_DIR/backup-$DATE.tar.gz" /home/user
echo "Backup completed: backup-$DATE.tar.gz"

Shell scripting is the foundation of Linux automation. Start simple and build complexity gradually.

Shell Basics and Navigation

2025-01-21T00:00:00-06:00

The shell is your primary interface to Linux. Master it, and you unlock the true power of the system.

Understanding the Shell

The shell is a command-line interpreter that reads your commands and executes them. The most common shell is Bash (Bourne Again Shell).

Essential Commands

Navigation

pwd          # Print working directory
cd /path     # Change directory
ls -la       # List files with details

File Operations

mkdir dirname    # Create directory
touch filename   # Create empty file
cp source dest   # Copy file
mv source dest   # Move/rename file
rm filename      # Remove file (careful!)

Viewing Files

cat filename     # Display entire file
less filename    # View file page by page
head filename    # First 10 lines
tail filename    # Last 10 lines

Paths and Permissions

Understanding absolute vs relative paths is crucial:

/home/user/file - absolute path
./file - relative to current directory
../file - relative to parent directory

File permissions use a three-tier system: owner, group, and others. Each can have read (r), write (w), and execute (x) permissions.

Practice

Try navigating your system:

cd ~
ls -la
cd /etc
ls | head -5

The shell is your gateway to everything. Master these basics before moving on!

Linux Security Fundamentals

2025-01-20T00:00:00-06:00

Security is not optional. Understanding Linux security fundamentals protects your systems and data.

User Management

useradd -m username      # Create user
passwd username          # Set password
usermod -aG group user   # Add to group
userdel -r username      # Delete user

File Permissions

chmod 755 file           # Set permissions
chmod u+x file           # User execute
chown user:group file    # Change ownership
chgrp group file         # Change group

Permission Numbers

4 = read
2 = write
1 = execute
755 = rwxr-xr-x
644 = rw-r--r--

SSH Security

# Disable password authentication
# Edit /etc/ssh/sshd_config
PasswordAuthentication no
PubkeyAuthentication yes

# Change default port
Port 2222

# Restrict users
AllowUsers user1 user2

Firewall Configuration

# UFW example
ufw default deny incoming
ufw default allow outgoing
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw enable

Fail2Ban

Protect against brute force attacks:

apt install fail2ban
systemctl enable fail2ban
systemctl start fail2ban

SELinux/AppArmor

Mandatory Access Control:

# SELinux (Red Hat)
getenforce
setenforce 1

# AppArmor (Debian/Ubuntu)
aa-status

Updates

apt update && apt upgrade    # Debian/Ubuntu
dnf update                   # Red Hat
pacman -Syu                  # Arch

Best Practices

Regular security updates
Strong passwords or key-based auth
Minimal installed software
Regular security audits
Encrypted sensitive data
Backup and recovery plans

Security is an ongoing process, not a one-time setup.

Process Management and Job Control

2025-01-19T00:00:00-06:00

Understanding processes is essential for system administration. Every running program is a process, and Linux gives you powerful tools to manage them.

Viewing Processes

ps - Process Status

ps aux              # All processes with details
ps -ef              # Full format listing
ps aux | grep nginx # Find specific process

top and htop

top                 # Interactive process viewer
htop                # Enhanced version (install separately)

Process Control

Background and Foreground

command &           # Run in background
fg                  # Bring to foreground
bg                  # Resume in background
jobs                # List background jobs

Signals

kill PID            # Send TERM signal
kill -9 PID         # Force kill (SIGKILL)
killall processname # Kill by name
pkill pattern       # Kill by pattern

Process Priorities

nice -n 10 command  # Start with lower priority
renice 15 PID       # Change priority of running process

Systemd Services

Modern Linux uses systemd for service management:

systemctl status service    # Check service status
systemctl start service     # Start service
systemctl stop service      # Stop service
systemctl restart service   # Restart service
systemctl enable service    # Enable on boot

Monitoring

# Watch process in real-time
watch -n 1 'ps aux | grep process'

# Monitor resource usage
iostat -x 1
vmstat 1

Understanding process management helps you troubleshoot issues and optimize system performance.

Package Management Systems

2025-01-18T00:00:00-06:00

Different Linux distributions use different package managers. Understanding them is crucial for system administration.

Debian/Ubuntu: apt

apt update                  # Update package lists
apt upgrade                 # Upgrade all packages
apt install package         # Install package
apt remove package          # Remove package
apt search keyword          # Search for packages
apt show package            # Show package info

Red Hat/CentOS: yum/dnf

dnf update                  # Update packages
dnf install package         # Install package
dnf remove package          # Remove package
dnf search keyword          # Search
dnf info package            # Package information

Arch Linux: pacman

pacman -Syu                 # Sync and upgrade
pacman -S package           # Install
pacman -R package           # Remove
pacman -Ss keyword          # Search
pacman -Qi package          # Info

Building from Source

Sometimes you need to compile software:

./configure
make
sudo make install

Snap and Flatpak

Universal package formats:

# Snap
snap install package
snap list

# Flatpak
flatpak install package
flatpak list

Best Practices

Always update package lists before installing
Use version pinning for production systems
Keep systems updated for security
Understand dependencies before removing packages

Package management is a core skill for maintaining Linux systems.

Networking Fundamentals

2025-01-17T00:00:00-06:00

Understanding networking is essential for system administration and troubleshooting connectivity issues.

Network Configuration

IP Configuration

ip addr show              # Show IP addresses
ip link show             # Show network interfaces
ip route show            # Show routing table

Traditional Commands

ifconfig                 # Interface configuration (deprecated)
route -n                 # Routing table
netstat -rn              # Network statistics

Network Interfaces

# Enable/disable interface
ip link set eth0 up
ip link set eth0 down

# Configure IP
ip addr add 192.168.1.10/24 dev eth0
ip addr del 192.168.1.10/24 dev eth0

DNS Configuration

cat /etc/resolv.conf     # DNS servers
host example.com         # DNS lookup
dig example.com          # Detailed DNS query
nslookup example.com     # Name server lookup

Network Testing

ping host                # Test connectivity
traceroute host          # Trace route
mtr host                 # My traceroute (continuous)
curl -I url              # HTTP request
wget url                 # Download file

Firewall Basics

iptables

iptables -L              # List rules
iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -j DROP

firewalld (Red Hat)

firewall-cmd --list-all
firewall-cmd --add-port=80/tcp --permanent
firewall-cmd --reload

ufw (Ubuntu)

ufw status
ufw allow 22/tcp
ufw enable

SSH

ssh user@host            # Connect
ssh -p 2222 user@host    # Custom port
ssh-keygen               # Generate key pair
ssh-copy-id user@host    # Copy public key

Network Troubleshooting

# Check connectivity
ping -c 4 8.8.8.8

# Check DNS
dig @8.8.8.8 google.com

# Check listening ports
ss -tulpn

# Monitor traffic
tcpdump -i eth0

Understanding networking helps you configure, secure, and troubleshoot Linux systems.

Log Analysis and Monitoring

2025-01-16T00:00:00-06:00

Logs are your window into system behavior. Learning to analyze them effectively is crucial for troubleshooting and monitoring.

Log Locations

/var/log/syslog          # System logs
/var/log/auth.log        # Authentication logs
/var/log/nginx/          # Web server logs
/var/log/apache2/        # Apache logs
/var/log/messages        # General messages

Viewing Logs

tail -f /var/log/syslog          # Follow in real-time
less /var/log/syslog             # Browse interactively
grep "error" /var/log/syslog     # Search for errors

journalctl (systemd)

journalctl -f                    # Follow logs
journalctl -u service            # Service-specific
journalctl --since "1 hour ago"  # Time-based
journalctl -p err                # Error level
journalctl -k                    # Kernel messages

Common Analysis Tasks

Find Errors

grep -i error /var/log/syslog | tail -20
journalctl -p err --since today

Count Occurrences

grep "pattern" logfile | wc -l
awk '{print $1}' logfile | sort | uniq -c

Extract Timestamps

grep "pattern" logfile | awk '{print $1, $2, $3}'

Log Rotation

Logs are rotated to prevent disk fill:

logrotate -d /etc/logrotate.conf  # Dry run
logrotate -f /etc/logrotate.conf  # Force rotation

Monitoring Tools

# Watch logs in real-time
tail -f /var/log/nginx/access.log | grep "404"

# Monitor multiple logs
multitail /var/log/syslog /var/log/auth.log

Best Practices

Regular log review
Automated log analysis scripts
Centralized logging for multiple systems
Proper log retention policies

Effective log analysis helps you catch issues early and understand system behavior.

Kubernetes Fundamentals

2025-01-15T00:00:00-06:00

Kubernetes orchestrates containers at scale, managing deployment, scaling, and operations of containerized applications.

Core Concepts

Pods

Smallest deployable unit. Contains one or more containers.

Services

Network abstraction providing stable IP and DNS name.

Deployments

Manages replica sets and rolling updates.

Namespaces

Virtual clusters for organizing resources.

Basic Commands

kubectl get pods              # List pods
kubectl get services          # List services
kubectl get deployments       # List deployments
kubectl describe pod name     # Pod details
kubectl logs pod-name         # Pod logs
kubectl exec -it pod-name -- /bin/sh  # Execute in pod

Deployment Example

apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 80

Service Example

apiVersion: v1
kind: Service
metadata:
  name: myapp-service
spec:
  selector:
    app: myapp
  ports:
  - port: 80
    targetPort: 80
  type: LoadBalancer

Apply Configuration

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml
kubectl get all

Scaling

kubectl scale deployment myapp --replicas=5
kubectl autoscale deployment myapp --min=2 --max=10

Updates

kubectl set image deployment/myapp myapp=myapp:v2
kubectl rollout status deployment/myapp
kubectl rollout undo deployment/myapp

ConfigMaps and Secrets

kubectl create configmap myconfig --from-file=config.properties
kubectl create secret generic mysecret --from-literal=key=value

Best Practices

Use declarative configuration
Version control all manifests
Use namespaces for organization
Set resource limits
Implement health checks
Use secrets for sensitive data

Kubernetes is the foundation of modern container orchestration.

Getting Started with Linux

2025-01-14T00:00:00-06:00

Welcome to your Linux exploration journey! This path serves as the foundation for everything that follows.

What is Linux?

Linux is a free and open-source operating system kernel that powers everything from smartphones to supercomputers. Unlike proprietary operating systems, Linux gives you complete control over your computing environment.

Why Explore Linux?

Freedom: Complete control over your system
Learning: Deep understanding of how computers work
Power: Access to powerful command-line tools
Community: Thriving ecosystem of developers and users

What You'll Learn

Throughout these paths, you'll discover:

Command-line mastery
System administration
Networking and security
Development environments
Automation and scripting

Choose your next path based on what interests you most. You can always return to explore different branches!

File System Hierarchy

2025-01-13T00:00:00-06:00

Linux organizes everything as files in a hierarchical tree structure. Understanding this structure is fundamental to system administration.

The Root Directory

Everything starts at / (root). Unlike Windows, Linux has a single unified file system.

Key Directories

`/bin` and `/usr/bin`

Essential user binaries and programs. /bin contains critical system binaries, while /usr/bin holds most user applications.

`/etc`

Configuration files for system-wide settings. This is where you'll find most configuration files.

`/home`

User home directories. Each user has a subdirectory here.

`/var`

Variable data files. Logs, caches, and temporary files that change during system operation.

`/tmp`

Temporary files. Usually cleared on reboot.

`/opt`

Optional software packages. Third-party applications often install here.

`/usr/local`

Locally installed software. This is where you'd install software manually.

Special Files

/dev - Device files representing hardware
/proc - Virtual filesystem showing process information
/sys - System information and configuration

Exploring the Structure

# See the structure
tree -L 2 /

# Check disk usage
df -h

# Find large files
du -sh /var/* | sort -h

Understanding the file system hierarchy helps you know where to find things and where to put new software.

CI/CD and Deployment Pipelines

2025-01-12T00:00:00-06:00

Continuous Integration and Deployment automate testing and deployment, reducing errors and speeding up releases.

GitLab CI/CD

.gitlab-ci.yml

stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - docker build -t myapp:$CI_COMMIT_SHA .
    - docker tag myapp:$CI_COMMIT_SHA myapp:latest

test:
  stage: test
  script:
    - docker run myapp:latest npm test

deploy:
  stage: deploy
  script:
    - docker-compose up -d
  only:
    - main

GitHub Actions

name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Deploy
        run: |
          docker build -t myapp .
          docker-compose up -d

Jenkins

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'docker build -t myapp .'
            }
        }
        stage('Test') {
            steps {
                sh 'docker run myapp npm test'
            }
        }
        stage('Deploy') {
            steps {
                sh 'docker-compose up -d'
            }
        }
    }
}

Deployment Strategies

Blue-Green Deployment

Run two identical environments, switch traffic between them.

Rolling Deployment

Gradually replace old instances with new ones.

Canary Deployment

Deploy to small subset, monitor, then roll out fully.

Best Practices

Automate everything
Test in staging first
Use version tags
Rollback plan ready
Monitor deployments
Document procedures

CI/CD transforms software delivery from manual to automated.

Containerization with Docker

2025-01-11T00:00:00-06:00

Containers package applications with their dependencies, making deployment consistent across environments.

Docker Basics

Installation

# Ubuntu/Debian
curl -fsSL https://get.docker.com -o get-docker.sh
sh get-docker.sh

# Arch Linux
pacman -S docker

Basic Commands

docker ps                    # Running containers
docker ps -a                 # All containers
docker images                # List images
docker pull image            # Download image
docker run image             # Run container
docker stop container        # Stop container
docker rm container          # Remove container

Dockerfile

FROM ubuntu:22.04
RUN apt-get update && apt-get install -y nginx
COPY index.html /var/www/html/
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Building

docker build -t myapp:latest .
docker run -p 8080:80 myapp:latest

Docker Compose

version: '3.8'
services:
  web:
    build: .
    ports:
      - "8000:80"
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb

docker-compose up -d
docker-compose down

Volume Management

docker volume create myvolume
docker run -v myvolume:/data container
docker run -v /host/path:/container/path container

Networking

docker network create mynetwork
docker run --network mynetwork container

Best Practices

Use specific image tags, not latest
Minimize image layers
Use multi-stage builds
Don't run as root in containers
Keep images small

Containers revolutionize how we deploy and manage applications.

Backup Strategies and Recovery

2025-01-10T00:00:00-06:00

Backups are your safety net. Without them, data loss is permanent. Learn to implement robust backup strategies.

Backup Types

Full Backup

Complete copy of all data. Most comprehensive but storage-intensive.

Incremental Backup

Only changed files since last backup. Faster and uses less space.

Differential Backup

All changes since last full backup. Balance between full and incremental.

Backup Tools

tar

# Create backup
tar -czf backup-$(date +%Y%m%d).tar.gz /path/to/backup

# Extract
tar -xzf backup-20250131.tar.gz

# List contents
tar -tzf backup-20250131.tar.gz

rsync

# Sync directories
rsync -avz /source/ /destination/

# Remote backup
rsync -avz -e ssh /local/ user@remote:/backup/

# Dry run
rsync -avzn /source/ /destination/

dd

# Disk image
dd if=/dev/sda of=/backup/disk.img bs=4M status=progress

# Restore
dd if=/backup/disk.img of=/dev/sda bs=4M status=progress

Database Backups

PostgreSQL

pg_dump database > backup.sql
pg_restore backup.sql

MySQL

mysqldump database > backup.sql
mysql database < backup.sql

Automated Backups

Cron Script

#!/bin/bash
BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d)
tar -czf "$BACKUP_DIR/backup-$DATE.tar.gz" /important/data
find $BACKUP_DIR -name "backup-*.tar.gz" -mtime +30 -delete

Offsite Backups

Cloud storage (S3, Backblaze)
Remote server via SSH
Physical media rotation
Multiple locations

Backup Verification

# Test restore
tar -tzf backup.tar.gz > /dev/null && echo "OK" || echo "FAILED"

# Compare checksums
md5sum original > checksum.txt
md5sum -c checksum.txt

Recovery Testing

Regularly test restore procedures
Document recovery steps
Know recovery time objectives (RTO)
Know recovery point objectives (RPO)

Best Practices

3-2-1 rule: 3 copies, 2 media types, 1 offsite
Automate backups
Verify backups regularly
Encrypt sensitive backups
Document procedures

Backups are worthless if you can't restore from them. Test regularly!