Profesionaliza tu entorno con Plantillas

Una de las mejores formas de ahorrar trabajo es que el propio sistema te de la opción de agilizar la realización de tareas.
Una de estas tareas creación repetitiva de ficheros.

En tu sistema GNU/Linux cuando usas un gestor de ficheros, y pulsas botón derecho tienes la opción de crear un nuevo documento, que por defecto es un fichero sin extensión y que no tiene ningún contenido:

Si nos fijamos el propio gestor de archivos nos indica en tono gris No hay ninguna plantilla

Directorio Plantillas ó Templates

Si navegamos con el gestor de ficheros veremos que en el home de nuestro usuario existe una carpeta con el nombre Templates ó Plantillas dependiendo del idioma con el que estés trabajando.

Aprovechar la carpeta ~/Plantillas (o ~/Templates) en Debian es una de las mejores formas de automatizar el trabajo diario.
Cuando colocamos un archivo en esa carpeta, el gestor de archivos (como Nautilus, Caja, Thunar o Nemo) te permite crearlo en cualquier sitio simplemente haciendo clic derecho y seleccionando "Nuevo documento".

Vamos a crear una selección de archivos de plantilla esenciales, estructurados de forma profesional y listos para ser guardados en tu directorio de plantillas por si te pueden ser útiles.

Utilizalos como base, puedes mejorarlos y compartirlos con el resto de la comunidad.

1. Automatización y Configuración

Dockerfile

Una base limpia y segura para empaquetar aplicaciones ligeras utilizando Debian como imagen base.

# =========================================================================
# Dockerfile de Plantilla - Entorno Base Seguro (Debian)
# =========================================================================

FROM debian:trixie-slim

LABEL maintainer="Tu Nombre <tu@email.com>"
LABEL version="1.0"
LABEL description="Plantilla base para contenedores Debian Linux"

# Configurar variables de entorno esenciales
ENV DEBIAN_FRONTEND=noninteractive \
    LANG=C.UTF-8 \
    LC_ALL=C.UTF-8

# Actualización del sistema e instalación de dependencias básicas
RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    ca-certificates \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# Crear un usuario no raíz por seguridad
RUN useradd -m -s /bin/bash appuser
WORKDIR /home/appuser
USER appuser

# Comando de inicio por defecto
CMD ["/bin/bash"]

script.sh

Un script en Bash que sigue las mejores prácticas: modo seguro (falla si hay errores), comprobación de privilegios y con ayuda integrada.

#!/usr/bin/env bash

# =========================================================================
# Nombre del Script: script.sh
# Descripción:       Plantilla base profesional para automatización en Bash
# Autor:             Tu Nombre <tu@email.com>
# =========================================================================

# Modo estricto de Bash para robustez y depuración
set -euo pipefail
IFS=$'\n\t'

# Variables globales y de entorno
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
LOG_FILE="/tmp/$(basename "${0}" .sh).log"

# Función de ayuda / uso
usage() {
    cat << EOF
Uso: $(basename "${0}") [OPCIONES]

Opciones:
    -h, --help    Muestra este mensaje de ayuda.
    -v, --verbose Activa el modo detallado.
EOF
    exit 1
}

# Control de ejecución como root (Descomentar si es necesario)
# if [[ ${EUID} -ne 0 ]]; then
#    echo "[-] Este script debe ejecutarse como root (sudo)." >&2
#    exit 1
# fi

# Procesamiento de argumentos
while [[ $# -gt 0 ]]; do
    case "${1}" in
        -h|--help) usage ;;
        -v|--verbose) set -x; shift ;;
        *) echo "[-] Opción desconocida: ${1}"; usage ;;
    esac
done

# --- LÓGICA PRINCIPAL DEL SCRIPT ---
main() {
    echo "[+] Iniciando script desde: ${SCRIPT_DIR}"
    # Tu código aquí
}

main

2. Documentación de Proyectos

README.md

El estándar para documentar cualquier repositorio o estructura de código de manera clara y jerárquica.

# Nombre del Proyecto

[![Licencia](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![OS](https://img.shields.io/badge/OS-Linux%20%2F%20Debian-lightgrey.svg)]()

Una descripción breve, clara y concisa de qué hace este proyecto y a quién va dirigido.

## Comenzando

Estas instrucciones te permitirán obtener una copia del proyecto en funcionamiento en tu máquina local para propósitos de desarrollo y pruebas.

### Requisitos previos

Qué cosas necesitas para instalar el software y cómo instalarlas:

```bash
sudo apt update
sudo apt install -y git build-essential
```

## Instalación

Paso a paso para configurar el entorno de desarrollo:

* Clonar el repositorio:
    ```bash
    git clone [https://github.com/usuario/proyecto.git](https://github.com/usuario/proyecto.git)
    ```
    
* Navegar al directorio e instalar dependencias:
    ```bash
    cd proyecto
    make install
    ```

## Uso

Explica cómo usar el proyecto con ejemplos de código o comandos comunes:
```
./ejecutable --config config.yaml
```

## Licencia

Este proyecto está bajo la Licencia (Por ejemplo: MIT) - mira el archivo LICENSE para detalles.

3. Docker Compose

compose.yaml

Estructura actual para levantar servicios en Docker utilizando las últimas especificaciones de formato.

name: mi-proyecto-base

services:
  web:
    image: nginx:alpine
    container_name: web_servidor
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
    networks:
      - red-local
    restart: unless-stopped

  db:
    image: postgres:15-alpine
    container_name: db_datos
    environment:
      POSTGRES_USER: usuario
      POSTGRES_PASSWORD: password_seguro
      POSTGRES_DB: mi_base_datos
    volumes:
      - datos_db:/var/lib/postgresql/data
    networks:
      - red-local
    restart: unless-stopped

networks:
  red-local:
    driver: bridge

volumes:
  datos_db:

Trucos Extra

Permisos de ficheros

Cuando termines de crear todos los ficheros que te van a servir de plantilla es importante que les permisos de ejecución a los scripts que quieras que se creen ya listos para usar:

# Permiso de ejecucion a todos los ficheros .sh
chmod +x ~/Plantillas/*.sh

Estructura de Proyectos

Este truco os va a encantar. Aunque el sistema de "Plantillas" nativo del gestor de archivos de Linux está pensado inicialmente para archivos individuales, puedes meter carpetas completas dentro de ~/Plantillas.

Cuando haces clic derecho -> Nuevo documento, el gestor de archivos copiará la carpeta entera con toda la estructura de subdirectorios y archivos que hayas preparado en su interior.

Aquí tienes un ejemplo profesional de cómo estructurar un directorio de proyecto base para desarrollo web o software, que puedes guardar directamente en tu carpeta de plantillas, usalo como base y prepara varios formatos de proyecto para tu trabajo.

Estructura de la Carpeta de Plantilla

Crea una carpeta llamada, por ejemplo, Proyecto-Base dentro de ~/Plantillas.
Su estructura interna puede ser la siguiente:

~/Plantillas/Proyecto-Base/
├── .gitignore
├── README.md
├── compose.yaml
├── src/
│   ├── index.html
│   ├── css/
│   │   └── styles.css
│   └── js/
│       └── main.js
└── scripts/
    └── deploy.sh

Contenido de los Ficheros de la Estructura

Al crear esta carpeta, es ideal que los archivos internos ya vengan preconfigurados para ahorrar el máximo tiempo posible:

.gitignore

Para evitar que se suban archivos basura de Linux o entornos de desarrollo al repositorio Git.

# Archivos del sistema Linux / Gestores de archivos
.directory
.DS_Store

# Archivos de configuración de editores (VS Code, VSCodium)
.vscode/
*.suo
*.ntvs*
*.njsproj
*.sln
*.swp

# Logs y bases de datos locales
*.log
*.sqlite

# Contenedores / Entorno
.env

scripts/deploy.sh

Un pequeño script automatizado para levantar el entorno de desarrollo rápidamente usando el archivo Compose de la raíz.

#!/usr/bin/env bash
set -euo pipefail

# Asegurar que nos movemos a la raíz del proyecto
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd)"
cd "${SCRIPT_DIR}/.."

echo "[+] Levantando el entorno de desarrollo Docker..."
docker compose up -d --build

echo "[+] Entorno listo. Accede a http://localhost:8080"

Cómo configurarlo en tu Debian

Puedes dejarlo listo desde tu terminal, solo tienes que ejecutar estos comandos (asumiendo que tu sistema usa el nombre Plantillas en español):

# 1. Crear la estructura de directorios dentro de Plantillas
mkdir -p ~/Plantillas/Proyecto-Base/src/css
mkdir -p ~/Plantillas/Proyecto-Base/src/js
mkdir -p ~/Plantillas/Proyecto-Base/scripts

# 2. Dar permisos de ejecución al script de despliegue
touch ~/Plantillas/Proyecto-Base/scripts/deploy.sh
chmod +x ~/Plantillas/Proyecto-Base/scripts/deploy.sh

A partir de este momento, cuando estés en cualquier ruta de tu sistema con tu gestor de archivos, haces Clic derecho -> Nuevo documento -> Proyecto-Base y se desplegará instantáneamente todo este árbol de directorios listo para trabajar.

Gestores de Archivos con soporte para estructura de Archivos en Plantillas

Este estructura de arbol de directorios no es capaz de usarla tal cual todos los gestores de archivos.

Os dejo una tabla organizada con los resultadoso de las prueba que he realizado para que os sirva dereferencia:

Compatibilidad de Estructuras de Carpetas en ~/Plantillas

Conclusión: La clonación nativa de estructuras de carpetas a través del menú de plantillas es una característica exclusiva del diseño de gestión de archivos centralizado de KDE Plasma (Dolphin/Konqueror). Para todos los demás, la solución es unicamente el uso de scripts automatizados en el menú contextual.

Aunque tu sistema se Gnome, XFCE, LXDE o cualquier otro, puedes instalar y usar sin ningún problema cualquier otro gestor de archivos, es lo genial de Linux.
Si quieres instalar Dolphin o Konqueror tan solo tienes que ejecutar los siguientes comandos y el propio sistema de encargará de resolver todas las dependencias:

# Instalar DOLPHIN
sudo apt -y install dolphin

# Instalar KONQUEROR
sudo apt -y install konqueror

Script Contextual para Gestores de Archivos sin soporte

La especificación XDG User Directories (que es la que gestiona la carpeta ~/Templates o ~/Plantillas) está diseñada nativamente para ficheros (MIME types), no para directorios.

• Nautilus (GNOME), Thunar (XFCE), Caja (MATE), Nemo, etc filtran estrictamente el contenido y solo muestran archivos planos para evitar que el usuario "rompa" la lógica del menú contextual creando carpetas vacías por error.
• Konqueror / Dolphin (KDE Plasma) es la excepción porque KIO (su arquitectura de entrada/salida) maneja las plantillas mediante archivos .desktop especiales que sí permiten clonar estructuras completas.

El método nativo de la carpeta ~/Plantillas no nos va a funcionar para estructuras de directorios en la mayoría de escritorios (como MATE, GNOME o XFCE), la solución definitiva, limpia y universal para cualquier gestor de archivos en Linux es el uso de Scripts.

En mi caso que uso MATE/Caja, haremos uso de un script para solucionarlo en el entorno actual.
Si se cambia de gestor de archivos en el futuro, la ruta en la dejar ese mismo script para que funcione con un solo clic derecho será la siguiente:

Dónde colocar el script según el gestor de archivos:

El script universal

Os dejo un script que no depende de las variables internas de Caja y que funcione en cualquier gestor de ficheros (Caja, Nautilus, Nemo, etc.), vamos a la herramienta zenity (que viene instalada por defecto en casi todo Debian) para que nos pregunte el nombre del proyecto antes de crearlo.

Guardamos este archivo como Crear Estructura Proyecto en la carpeta de scripts del gestor actual (ver tabla anterior):

#!/usr/bin/env bash
set -euo pipefail

# 1. Preguntar al usuario el nombre del proyecto mediante una ventana gráfica
NOMBRE_PROYECTO=$(zenity --entry --title="Nuevo Proyecto" --text="Introduce el nombre de la carpeta:" --entry-text="mi-proyecto")

# Si el usuario cancela o lo deja vacío, salimos
if [ -z "$NOMBRE_PROYECTO" ]; then
    exit 0
fi

# 2. Obtener el directorio actual de forma segura
# Si la variable del gestor falla, usamos el pwd de ejecución
TARGET_DIR="${CAJA_SCRIPT_CURRENT_URI:-$PWD}"
TARGET_DIR=$(echo "$TARGET_DIR" | sed 's/^file:\/\///' | sed 's/%20/ /g')

NUEVA_RUTA="${TARGET_DIR}/${NOMBRE_PROYECTO}"

# 3. Crear la estructura
mkdir -p "$NUEVA_RUTA"/{src/css,src/js,scripts}

# 4. Crear archivos base
cat << 'EOF' > "$NUEVA_RUTA"/.gitignore
.directory
.DS_Store
*.log
.env
EOF

cat << 'EOF' > "$NUEVA_RUTA"/README.md
# Proyecto creado desde plantilla de scripts
EOF

touch "$NUEVA_RUTA"/src/css/styles.css
touch "$NUEVA_RUTA"/src/js/main.js

# Notificación visual de éxito
notify-send "Estructura Creada" "Se ha creado el proyecto en: $NUEVA_RUTA" --icon=folder

Recuerda darle siempre permisos de ejecución con chmod +x al archivo del script para que el gestor de archivos lo reconozca.

Amplia o modifica el script para adaptarlo a la estructura que necesita tu proyecto.