WSL Mastery

# Instala WSL 2 con Ubuntu por defecto
wsl --install

# Si quieres elegir la distribución:
wsl --install -d Ubuntu-22.04

# Listar distribuciones disponibles en la tienda
wsl --list --online

NAME                            FRIENDLY NAME
Ubuntu                          Ubuntu
Ubuntu-22.04                    Ubuntu 22.04 LTS
Ubuntu-20.04                    Ubuntu 20.04 LTS
Debian                          Debian GNU/Linux
kali-linux                      Kali Linux Rolling
openSUSE-42                     openSUSE Leap 42

# Ver distribuciones instaladas
wsl --list --verbose

  NAME            STATE           VERSION
* Ubuntu-22.04    Running         2
  Debian          Stopped         2

# Establecer WSL 2 como versión por defecto
wsl --set-default-version 2

# Convertir distro de WSL1 a WSL2
wsl --set-version Ubuntu 2

# Iniciar una distribución específica
wsl -d Ubuntu-22.04

# Apagar todas las distribuciones
wsl --shutdown

# Actualizar el kernel de WSL
wsl --update

# Ver versión actual
wsl --version

# pwd — Print Working Directory (dónde estás)
pwd
/home/usuario

# ls — List files (listar archivos)
ls
Desktop  Documents  Downloads  Music  Pictures

# ls con detalles y archivos ocultos
ls -la
total 52
drwxr-xr-x 8 usuario usuario 4096 Jun 26 09:00 .
drwxr-xr-x 3 root    root    4096 Jun 25 18:00 ..
-rw-r--r-- 1 usuario usuario  220 Jun 25 18:00 .bash_logout
drwxr-xr-x 2 usuario usuario 4096 Jun 26 09:00 Documents

# cd — Change Directory (cambiar directorio)
cd Documents
cd ..          # Sube un nivel
cd ~           # Va al home del usuario
cd /           # Va a la raíz del sistema
cd -           # Va al directorio anterior

# Crear directorio
mkdir mi_proyecto
mkdir -p proyectos/web/css    # Crea directorios anidados

# Crear archivo vacío
touch archivo.txt

# Escribir en un archivo
echo "Hola WSL" > hola.txt      # Sobreescribe
echo "Segunda línea" >> hola.txt  # Agrega al final

# Leer archivos
cat hola.txt                     # Muestra el contenido
less archivo_largo.txt           # Lectura paginada
head -n 5 archivo.txt            # Primeras 5 líneas
tail -n 5 archivo.txt            # Últimas 5 líneas
tail -f /var/log/syslog          # Seguir un log en vivo

# Copiar, mover, eliminar
cp origen.txt destino.txt
mv archivo.txt nueva_ruta/
rm archivo.txt
rm -rf directorio/              # ¡Cuidado! Elimina todo

# find — buscar archivos
find . -name "*.txt"             # Por nombre
find /home -size +10M            # Por tamaño (>10MB)
find . -type d                   # Solo directorios
find . -mtime -7                 # Modificados últimos 7 días

# grep — buscar dentro de archivos
grep "error" logfile.txt        # Busca "error"
grep -r "TODO" ./src/           # Recursivo
grep -i "usuario" config.txt    # Sin distinción mayúsculas
grep -n "error" app.log         # Con número de línea

# Combinar con pipes
cat access.log | grep "404" | wc -l  # Contar errores 404

# Acceder al escritorio de Windows
cd /mnt/c/Users/TuNombre/Desktop

# Acceder a Documentos
cd /mnt/c/Users/TuNombre/Documents

# Listar archivos de C:
ls /mnt/c/

# Copiar archivo de Windows a Linux
cp /mnt/c/Users/TuNombre/archivo.txt ~/

# Crear alias para acceso rápido
echo 'alias cdesktop="cd /mnt/c/Users/TuNombre/Desktop"' >> ~/.bashrc
source ~/.bashrc

# Abrir el home de Linux en el Explorador de Archivos
explorer.exe .     # Desde la terminal WSL

# En PowerShell, acceder a Linux via UNC path
dir \\wsl$\Ubuntu-22.04\home\usuario

# En el Explorador: busca "Linux" en el panel izquierdo
# O escribe en la barra: \\wsl$\Ubuntu-22.04

# Ver permisos
ls -la script.sh
-rwxr-xr-- 1 usuario grupo 1234 Jun 26 09:00 script.sh
# │││├─ usuario: rwx (leer, escribir, ejecutar)
# ││├── grupo: r-x (leer, ejecutar)
# │└─── otros: r-- (solo leer)

# Cambiar permisos (chmod)
chmod +x script.sh      # Hacer ejecutable
chmod 755 script.sh     # rwxr-xr-x (octal)
chmod 644 archivo.txt   # rw-r--r--
chmod -R 755 directorio/ # Recursivo

# Cambiar propietario (chown)
sudo chown usuario:grupo archivo.txt
sudo chown -R usuario directorio/

# SIEMPRE actualiza la lista de paquetes primero
sudo apt update
Hit:1 http://archive.ubuntu.com/ubuntu jammy InRelease
Reading package lists... Done
Building dependency tree... Done
42 packages can be upgraded.

# Actualizar paquetes instalados
sudo apt upgrade -y

# Instalar un paquete
sudo apt install git
sudo apt install python3 python3-pip -y

# Buscar un paquete
apt search nodejs
apt show curl         # Información detallada

# Eliminar paquetes
sudo apt remove paquete
sudo apt purge paquete  # Elimina también configuración
sudo apt autoremove     # Elimina dependencias huérfanas

# Limpiar cache
sudo apt clean

# Actualizar e instalar herramientas base
sudo apt update && sudo apt upgrade -y
sudo apt install -y git curl wget build-essential

# Python
sudo apt install -y python3 python3-pip python3-venv
python3 --version
Python 3.10.12

# Node.js (vía nvm - recomendado)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install --lts
node --version
v20.14.0

# Git configuración inicial
git config --global user.name "Tu Nombre"
git config --global user.email "tu@email.com"
git config --global core.editor "code --wait"

# htop — monitor de sistema interactivo
sudo apt install htop
htop

# tmux — multiplexor de terminal
sudo apt install tmux

# zsh + oh-my-zsh — shell mejorada
sudo apt install zsh
sh -c "$(curl -fsSL https://raw.github.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

# bat — cat con sintaxis coloreada
sudo apt install bat
batcat archivo.py

# fzf — buscador difuso
sudo apt install fzf

# tree — mostrar árbol de directorios
sudo apt install tree
tree -L 2 ./mi_proyecto

[wsl2]
# Memoria RAM asignada a WSL (por defecto: 50% del sistema)
memory=8GB

# Núcleos de CPU (por defecto: todos los del sistema)
processors=4

# Memoria de swap
swap=2GB

# Habilitar soporte para GUI apps (WSLg)
guiApplications=true

# Networking — mirrored para mejor integración
networkingMode=mirrored

# Auto-reclamar memoria no usada
autoMemoryReclaim=gradual

# Habilitar DNS tunneling
dnsTunneling=true

# Habilitar firewall de Windows
firewall=true

[automount]
# Montar drives de Windows automáticamente
enabled = true
root = /mnt/
# Opciones de montaje (drs: acceso a metadatos Windows)
options = "metadata,umask=22,fmask=11"
mountFsTab = true

[boot]
# Ejecutar systemd (WSL2 con kernel 5.15+)
systemd = true
# Ejecutar script al iniciar
command = "service ssh start"

[network]
# Nombre del host en la red
hostname = mi-wsl-dev
# Generar /etc/hosts automáticamente
generateHosts = true
generateResolvConf = true

[interop]
# Permitir ejecutar binarios de Windows desde Linux
enabled = true
appendWindowsPath = true

# Agregar al final de ~/.bashrc

# Alias útiles
alias ll='ls -alF'
alias la='ls -A'
alias cls='clear'
alias update='sudo apt update && sudo apt upgrade -y'
alias myip='curl ifconfig.me'

# Acceso rápido al escritorio de Windows
export WIN_HOME="/mnt/c/Users/TuNombre"
alias cdesktop="cd $WIN_HOME/Desktop"
alias cdocs="cd $WIN_HOME/Documents"

# Prompt personalizado con colores
export PS1='\[\033[01;32m\]\u@wsl\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '

# Aplicar cambios
source ~/.bashrc

# Ver IP de WSL
ip addr show eth0
hostname -I
172.20.48.1

# Ver puertos en uso
ss -tulpn
netstat -tulpn

# Probar conectividad
ping google.com -c 4
curl -I https://google.com

# Desde WSL, obtener IP del host Windows
cat /etc/resolv.conf | grep nameserver
nameserver 172.20.48.1   # Esta es la IP del host Windows

# Configurar una variable de entorno con la IP del host
export HOST_IP=$(cat /etc/resolv.conf | grep nameserver | awk '{print $2}')
echo $HOST_IP

# Iniciar servidor web simple en puerto 8080
python3 -m http.server 8080
Serving HTTP on 0.0.0.0 port 8080 (http://0.0.0.0:8080/) ...

# Ahora en Windows, abre el navegador en:
# http://localhost:8080
# WSL redirige el puerto automáticamente

# Instalar y levantar Nginx
sudo apt install nginx
sudo service nginx start
# → Abre http://localhost en Windows

# Instalar cliente SSH (ya viene instalado)
ssh usuario@servidor.com
ssh -p 2222 usuario@192.168.1.100

# Generar clave SSH en WSL
ssh-keygen -t ed25519 -C "tu@email.com"
Generating public/private ed25519 key pair.
Enter file in which to save the key (/home/usuario/.ssh/id_ed25519):

# Copiar clave pública al servidor
ssh-copy-id usuario@servidor.com

# Configurar SSH para múltiples hosts
nano ~/.ssh/config

# Desde cualquier directorio en WSL, abre VS Code
code .

# Abre un archivo específico
code archivo.py

# VS Code detecta automáticamente que estás en WSL
# e instala el servidor "VS Code Server" en Linux

# Verificar Docker funciona en WSL
docker --version
Docker version 25.0.3, build 4debf41

# Correr tu primer contenedor
docker run hello-world

# Correr Nginx en Docker
docker run -d -p 8080:80 --name mi-nginx nginx
# → Abre http://localhost:8080 en Windows

# Ver contenedores activos
docker ps

# Docker Compose
docker compose up -d
docker compose logs -f
docker compose down

# PostgreSQL
sudo apt install postgresql postgresql-contrib
sudo service postgresql start
sudo -u postgres psql

# MySQL
sudo apt install mysql-server
sudo service mysql start
sudo mysql

# Redis
sudo apt install redis-server
sudo service redis-server start
redis-cli ping
PONG

# Con systemd activado, usa systemctl
sudo systemctl enable postgresql
sudo systemctl start postgresql

#!/bin/bash
# La primera línea (shebang) indica qué intérprete usar

# Variables
NOMBRE="AutoNovations"
FECHA=$(date +"%Y-%m-%d")  # Capturar salida de comando

# Echo con colores
echo -e "\033[36m=== WSL Master Script ===\033[0m"
echo "Hola desde $NOMBRE — $FECHA"

# Condicionales
if [ -d "/tmp/test" ]; then
    echo "El directorio /tmp/test existe"
else
    mkdir /tmp/test
    echo "Directorio creado: /tmp/test"
fi

# Bucle for
for i in 1 2 3 4 5; do
    echo "Iteración: $i"
done

# Funciones
saludar() {
    local nombre=$1
    echo "¡Bienvenido, $nombre!"
}

saludar "DevOps Engineer"

# Crear el archivo
nano hello_wsl.sh

# Hacerlo ejecutable
chmod +x hello_wsl.sh

# Ejecutarlo
./hello_wsl.sh
=== WSL Master Script ===
Hola desde AutoNovations — 2024-06-26
Directorio creado: /tmp/test
Iteración: 1
Iteración: 2
Iteración: 3
Iteración: 4
Iteración: 5
¡Bienvenido, DevOps Engineer!

#!/bin/bash
# Script para configurar un nuevo proyecto Python

set -e  # Salir si hay algún error

PROJECT_NAME=${1:-"mi_proyecto"}  # Parámetro o default
PYTHON=python3

echo "🚀 Creando proyecto: $PROJECT_NAME"

# Crear estructura
mkdir -p $PROJECT_NAME/{src,tests,docs}
cd $PROJECT_NAME

# Entorno virtual
$PYTHON -m venv .venv
source .venv/bin/activate

# Archivos base
cat > README.md <<EOF
# $PROJECT_NAME
Proyecto creado con WSL + AutoNovations setup script.
EOF

touch src/__init__.py tests/__init__.py
echo "requests\npytest" > requirements.txt
pip install -r requirements.txt -q

# Inicializar git
git init && git add . && git commit -m "Initial commit"

echo "✅ Proyecto $PROJECT_NAME listo en $(pwd)"

# Abrir el editor de cron del usuario actual
crontab -e

# Formato: MIN HORA DIA MES DIASEMANA COMANDO

# Ejecutar backup.sh cada día a las 2:00 AM
0 2 * * * /home/usuario/scripts/backup.sh

# Ejecutar cada 5 minutos
*/5 * * * * /home/usuario/scripts/monitor.sh

# Ver cron jobs activos
crontab -l

# Exportar distro a archivo .tar
wsl --export Ubuntu-22.04 C:\backups\ubuntu-dev.tar

# Importar en otro equipo o con otro nombre
wsl --import Ubuntu-Dev C:\WSL\Ubuntu-Dev C:\backups\ubuntu-dev.tar

# Verificar importación
wsl --list --verbose

# Iniciar la distro importada
wsl -d Ubuntu-Dev

# Instalar Gedit (editor de texto gráfico)
sudo apt install gedit
gedit &   # Se abre en tu escritorio Windows

# Instalar navegador Firefox
sudo apt install firefox
firefox &

# Instalar Nautilus (explorador de archivos GNOME)
sudo apt install nautilus
nautilus &

# Ver variable DISPLAY (debería estar configurada)
echo $DISPLAY
:0

# Instalar múltiples distribuciones
wsl --install -d Ubuntu-22.04
wsl --install -d Debian
wsl --install -d kali-linux

# Establecer distribución por defecto
wsl --set-default Ubuntu-22.04

# Ejecutar comando en una distro específica
wsl -d Debian -- apt list --installed

# Terminar una distro específica
wsl --terminate Debian

# Eliminar una distro completamente
wsl --unregister Debian