Si has recibido notificaciones de que tu disco está lleno o simplemente quieres optimizar el espacio en tu VPS, este pequeño tutorial te guiará paso a paso para limpiar tu sistema usando algunos comandos útiles y seguros.

## 🔍 Paso 1: Verifica el uso del disco

Primero, vamos a ver qué particiones están ocupando más espacio.

```bash
df -h
```

Este comando muestra el uso del espacio en disco de forma amigable. Busca la línea donde aparece `/` (raíz), y si ves que está al 90% o más, es momento de limpiar.

---

## 🔍 Paso 2: Localiza carpetas grandes

Para identificar cuáles son las carpetas que consumen más espacio dentro de tu directorio personal, ejecuta:

```bash
du -h --max-depth=1 ~/ | sort -h
```

- `du`: Muestra el tamaño de los directorios.
- `-h`: Hace que la salida sea legible por humanos (ej. 1K, 234M, 2G).
- `--max-depth=1`: Solo muestra el tamaño de las carpetas directas dentro de `~/`.
- `| sort -h`: Ordena los resultados por tamaño.

Esto te ayudará a identificar fácilmente qué directorios están ocupando más espacio.

---

## 🐳 Paso 3: Limpia recursos de Docker no utilizados

Si usas Docker, probablemente tengas imágenes, contenedores o caches que ya no necesitas. Puedes eliminarlos rápidamente con:

```bash
docker system prune -af
```

Este comando elimina:
- Contenedores detenidos
- Redes no utilizadas
- Imágenes colgantes (dangling)
- Build cache

---

## ⚙️ Configura docker para limitar el tamaño de los logs de los contenedores

Crea (si no existe) el archivo `daemon.json` localizado en Linux en `/etc/docker/` y agrega lo siguiente:

```json
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  }
}
```
Para saber más sobre esta configuración puedes visitar [la documentación](https://docs.docker.com/engine/logging/drivers/json-file/#usage)

---

## 📖 Paso 4: Limpia los logs del sistema (journalctl)

Los logs del sistema pueden ocupar mucho espacio con el tiempo. Para borrar registros antiguos y dejar solo los del último día:

```bash
sudo journalctl --vacuum-time=1d
```

Este comando borra todos los logs anteriores a 24 horas.

> 💡 Puedes ajustar el tiempo cambiando `1d` por otro valor, como `1w` para una semana.

---

## ✅ Conclusión

Con estos simples pasos, puedes recuperar espacio valioso en tu VPS sin riesgo innecesario:

1. Usa `df -h` para revisar espacio.
2. Usa `du -h --max-depth=1 ~/ | sort -h` para encontrar carpetas pesadas.
3. Ejecuta `docker system prune` si usas Docker.
4. Limpia los logs con `sudo journalctl --vacuum-time=1d`.

¡Tu servidor volverá a respirar! 🌬️

---

¿Tienes otros trucos para mantener tu VPS limpio? ¡Déjalo en los comentarios!

Liberar Espacio en un VPS con Linux

Java es una herramienta esencial para desarrolladores y administradores de sistemas. En Linux, es común tener múltiples versiones de Java instaladas para satisfacer diferentes necesidades. Sin embargo, gestionar estas versiones puede ser un desafío si no sabes cómo listarlas o cambiar entre ellas. En este post, te explicaré cómo hacerlo paso a paso.

---

## Listar las Versiones de Java Instaladas

Para verificar qué versiones de Java tienes instaladas en tu sistema, puedes usar varios comandos dependiendo de cómo se haya instalado Java (a través del administrador de paquetes o manualmente).

### 1. Usar `update-java-alternatives`

Si instalaste Java usando el administrador de paquetes de tu distribución (por ejemplo, `apt` en Ubuntu/Debian), puedes usar el comando `update-java-alternatives`:

```bash
sudo update-java-alternatives --list
```

**Ejemplo de salida:**
```
java-1.17.0-openjdk-amd64      1700       /usr/lib/jvm/java-1.17.0-openjdk-amd64
java-11-openjdk-amd64          1100       /usr/lib/jvm/java-11-openjdk-amd64
java-8-oracle                  1081       /usr/lib/jvm/java-8-oracle
```

Este comando muestra las versiones instaladas y sus rutas.

---

### 2. Usar `update-alternatives`

El comando `update-alternatives` también puede usarse para listar las versiones de Java disponibles en tu sistema:

```bash
update-alternatives --list java
```

**Ejemplo de salida:**
```
/usr/lib/jvm/java-11-openjdk-amd64/bin/java
/usr/lib/jvm/java-8-oracle/bin/java
```

Esto muestra las rutas de las versiones de Java instaladas.

También puedes listar otras herramientas de Java, como el compilador (`javac`):

```bash
update-alternatives --list javac
```

---

### 3. Ver la Versión Activa

Para verificar la versión de Java que está configurada como predeterminada en tu sistema, usa:

```bash
java -version
```

**Ejemplo de salida:**
```
openjdk version "11.0.15" 2022-04-19
OpenJDK Runtime Environment (build 11.0.15+10-Ubuntu-0ubuntu0.20.04.1)
OpenJDK 64-Bit Server VM (build 11.0.15+10-Ubuntu-0ubuntu0.20.04.1, mixed mode, sharing)
```

Este comando solo muestra la versión activa actualmente.

---


## Cambiar entre Versiones de Java

Si tienes varias versiones instaladas y deseas cambiar la versión predeterminada, puedes hacerlo fácilmente con `update-alternatives`.

### 1. Cambiar la Versión Predeterminada

Usa el siguiente comando:

```bash
sudo update-alternatives --config java
```

**Ejemplo de salida:**
```
There are 3 choices for the alternative java (providing /usr/bin/java).

  Selection    Path                                            Priority   Status
------------------------------------------------------------
* 1            /usr/lib/jvm/java-11-openjdk-amd64/bin/java     1100      auto mode
  2            /usr/lib/jvm/java-8-oracle/bin/java             1081      manual mode
  3            /usr/lib/jvm/java-17-openjdk-amd64/bin/java     1700      manual mode

Press <enter> to keep the current choice[*], or type selection number:
```

Selecciona el número correspondiente a la versión que deseas usar.

---

### 2. Verificar el Cambio

Después de cambiar la versión, verifica que la versión activa sea la correcta:

```bash
java -version
```

---

## Conclusión

Listar y cambiar entre versiones de Java en Linux es un proceso sencillo si conoces los comandos adecuados. Usa `update-java-alternatives`. Esto te permitirá trabajar con la versión correcta según tus necesidades.

Cómo listar y cambiar entre versiones de Java en Linux

Guía de Instalación y Uso de yt-dlp: Descarga Contenido Multimedia desde la Línea de Comandos

**yt-dlp** es una herramienta de línea de comandos de código abierto diseñada para descargar videos y audio de YouTube. Es un fork mejorado de `youtube-dl`, con actualizaciones frecuentes, soporte para más plataformas y opciones avanzadas. A continuación, te explicamos cómo instalarlo y usarlo.

---

## **Instalación**

Para instalar sigue las intrucciones que aparecen en el siguiente enlace [yt-dlp instalación](https://github.com/yt-dlp/yt-dlp/wiki/Installation) , recomiendo instalarlo desde [el archivo binario](https://github.com/yt-dlp/yt-dlp/wiki/Installation#installing-the-release-binary) 

---

## **Uso Básico**

### **1. Descargar un Video**
```bash
yt-dlp [URL_DEL_VIDEO]
```
Ejemplo: esto descargará el video con el mejor audio y video posible
```bash
yt-dlp https://youtu.be/SigIbCVMTzU?si=1Tl49J2umQ327wpt
```

Ejemplo 2: esto descargará el video en una calidad que sea igual o menor a 720p según esté disponible y con el mejor audio
```bash
yt-dlp https://youtu.be/SigIbCVMTzU?si=1Tl49J2umQ327wpt -f "bestvideo[height<=720]+bestaudio"
```

### **2. Seleccionar Calidad de Video**

- **Lista de formatos disponibles:**
  ```bash
  yt-dlp [URL] -F 
  ```

### **3. Descargar Audio Únicamente**

```bash
yt-dlp [URL] -x --audio-format mp3 
```
*(Requiere FFmpeg para convertir a MP3).*

### **4. Descargar una Lista de Reproducción**
```bash
yt-dlp -o "%(playlist)s/%(title)s.%(ext)s" [URL_DE_PLAYLIST]
```

### **5. Especificar Carpeta de Destino**
```bash
yt-dlp -o "/ruta/a/carpeta/%(title)s.%(ext)s" [URL]
```

---

## **Beneficios de yt-dlp**


- **Actualizaciones Constantes:** Mejoras frecuentes para evitar bloqueos y añadir nuevas funciones.
- **Personalización Avanzada:** Elige formatos, calidades, subtítulos, y más con opciones detalladas.
- **Extracción de Audio:** Convierte videos a MP3, OGG, o otros formatos usando FFmpeg.
- **Gratis y Open Source:** Código abierto bajo licencia MIT.

---

## **Ejemplo Práctico**
```bash
yt-dlp https://youtu.be/SigIbCVMTzU?si=1Tl49J2umQ327wpt -f "bestvideo[height<=1080]+bestaudio" -o "~/Videos/%(title)s.mp4"
```
Este comando descarga un video en 1080p (o inferior) con el mejor audio y lo guarda en `~/Videos`.

---

¡Empieza a usar **yt-dlp** para gestionar tus descargas multimedia de forma eficiente! Para más opciones, ejecuta `yt-dlp --help` o visita el [repositorio oficial](https://github.com/yt-dlp/yt-dlp).

Descargar videos de youtube desde la terminal linux

En este tutorial te voy a mostrar como configurar un servidor de correo que puedas usar usando el cliente **Mozilla Thunderbird**.

Aclarar que este tutorial esta hecho sobre el sitema operativo Linux Mint. 

1- instalaremos postfix
```conosle
sudo DEBIAN_PRIORITY=low apt install postfix
```
En la ventana interactiva seleccionaremos las siguientes opciones en donde usaremos las teclas <kbd>Enter</kbd> ,<kbd>Tab</kbd> , y las flechas arriba o abajo para movernos.

- _General mail configuration type_: **Sitio de Internet** o **Internet Site** en dependencia del idioma de su sistema.
- _System mail name_: Lo dejamos tal cual nos aparece.
- _Recipient for root and postmaster mail_: Escribimos el nombre de nuestro usuario en mi caso es **raul**
- _Otros destinos para los cuales aceptar correo_:Lo dejamos como mismo aparece.
- _¿Forzar actualizaciones síncronas en la cola de correo?_: **No**
- _Local networks_:Lo dejamos como mismo.
- _Mailbox size limit (bytes)_: **0**   
- _Local address extension character:_ **+**
- _Protocolos de Internet a usar_: **todos**

Esta es toda la configuración necesaria en postfix. Podemos comprobar que el servidor de correo esta funcionando usando `telnet localhost 25`

2 - Intalaremos dovecot
```conosle
sudo apt-get install dovecot-imapd
```

Y agregaremos la siguiente configuración al final del archivo ubicado en `/etc/dovecot/dovecot.conf` usando el comando sudo si fuera necesario.

```console
mail_location = mbox:~/mail:INBOX=/var/mail/%u
disable_plaintext_auth = no
protocols = " imap"
mail_privileged_group = mail
```

3 - Abrimos el cliente de correo Mozilla Thunderbird y agregamos nuestro correo **usuariosistema@localhost** y en caso de que sea necesario les dejo la siguiente configuración:

IMAP Mail Server:
- Server name : localhost
- User Name : raul (tu nombre de usuario)
- Port : 143
Outgoing Server (SMTP):
- Server name : localhost
- User Name : raul (tu nombre de usuario)
- Port : 25

En caso de que nos pida alguna contraseña usaremos la misma que la del usuario del sistema y permitiremos cualquier excepción de seguridad.

Configurando servidor de correo local para fines de pruebas y desarrollo

Tenemos dos instancias de postgresql corriendo en contenedores diferentes en nuestro sistema .El nombre del primer contenedor es **basededatos-1** y el segundo es **basededatos-2** al cual importaremos los datos de **basededatos-1**.

**basededatos-1** posee un conjunto de base de datos con diferentes tipo de contenidos y el contenedor **basededatos-2** está completamente vacío. 

#### 1- Exportar todos los datos almacenados en el contenedor basededatos-1.

Lo primero que haremos será entrar a la terminal bash del contenedor usando este comando.

```bash
docker exec -it basededatos-1 bash
```

Luego exportamos todos los datos con el siguiente comando especificando el usuario establecido y el puerto si estamos usando uno diferente al que hay por defecto por ejemplo yo estoy usando el puerto 1458.

```bash
pg_dumpall -U usuario -p 1458 > backup.sql
```

Esto nos crea un archivo llamado **backup.sql** con todos los datos guardados en el contenedor basededatos-1 si ejecutamos el comando **ls** obtendremos algo como esto
```bash
backup.sql                  etc                         opt                         srv
home                        proc                        sys
bin                         lib                         root                        tmp
dev                         media                       run                         usr
docker-entrypoint-initdb.d  mnt                         sbin                        var
```
Para terminar con el trabajo en basededatos-1 nos salimos de su terminal bash con el comando `exit`.

#### 2- Mover el archivo backup.sql para el contenedor basededatos-2
Ahora vamos a copiar el archivo backup.sql que contiene todos los datos exportados de **basededatos-1** al contenedor **basededatos-2**.Para esto usamos los siguientes comandos en la terminal.

Primero copiamos el archivo backup.sql a una ruta en nuestro sistema de archivos, yo por ejemplo lo pondré en mi carpeta de usuario.

```bash
docker cp basededatos-1:/backup.sql /home/raul
```

Y luego copiamos el mismo archivo para el contenedor **basededatos-2**.
```bash
docker cp /home/raul/backup.sql basededatos-2:/
```

Y para finalizar este paso entramos a la terminal de nuestro contenedor **basededatos-2** para comprobar que se encuentre el archivo backup.sql ejecutando nuevamente el comando `ls`.

```bash
docker exec -it basededatos-2 bash
```

#### 3- Importamos todos los datos en basededatos-2 desde el archivo backup.sql.

Como en **basededatos-2** estoy usando el puerto `1468` tengo que especificarlo. Usamos este comando para importar todas las bases de datos con su respectivo contenido.

```bash
psql -U usuario -p 1468 -f backup.sql
```
Una vez terminado podemos comprobar que todo se realizó con éxito comprobando la lista de base de datos con el siguiente comando.

```bash
psql -U usuario -p 1468 -l
```

Copiar los datos de una base de datos PostgreSQL a otra alojadas en diferentes contenedores docker

Las operaciones ternarias son una característica poderosa y elegante en Python que permite escribir código más conciso. En este artículo, exploraremos los diferentes tipos de operaciones ternarias en Python y cómo pueden mejorar la legibilidad de tu código.

**1. Operador Ternario Básico:**
El operador ternario básico en Python sigue la sintaxis `valor_si_verdadero if condicion else valor_si_falso`. Aquí, examinaremos ejemplos prácticos y cómo esta estructura simplifica condicionales simples.

```python
resultado = "Es positivo" if numero > 0 else "Es negativo o cero"
```

**2. Operador Ternario Anidado:**
La anidación de operadores ternarios permite manejar condiciones más complejas de manera eficiente. Exploraremos cómo usar múltiples operadores ternarios para mejorar la claridad del código.

```python
resultado = "Par" if numero % 2 == 0 else ("Impar positivo" if numero > 0 else "Cero o impar negativo")
```

**3. Operador Ternario con Expresiones Lambda:**
Aprovechando las expresiones lambda, podemos crear operadores ternarios en una sola línea para funciones simples. Esto es especialmente útil al trabajar con funciones pequeñas.

```python
es_mayor = lambda x, y: x if x > y else y
```

**4. Operador Ternario con Múltiples Condiciones:**
¿Qué sucede cuando tenemos más de dos condiciones? Descubre cómo utilizar el operador ternario con múltiples condiciones para manejar situaciones más complejas sin perder la elegancia.

```python
resultado = "Aprobado" if puntaje >= 70 else "Aprobado con Distinción" if puntaje >= 90 else "Reprobado"
```

En resumen, las operaciones ternarias son una herramienta valiosa para simplificar y mejorar la legibilidad de tu código en Python. Ya sea para condicionales simples o complejas, su uso puede hacer que tu código sea más conciso y fácil de entender. ¡Aprovéchalas en tus proyectos para escribir código más elegante y eficiente!

Explorando las Operaciones Ternarias en Python: Concisión y Elegancia

Windows:

1. Abre la línea de comandos: Presiona la tecla `Win` y escribe "cmd" en la barra de búsqueda. Haz clic en "Símbolo del sistema" para abrir la línea de comandos.

2. Crea un nuevo entorno virtual: En la línea de comandos, ejecuta el siguiente comando para crear un nuevo entorno virtual con el nombre "myenv" (puedes cambiar el nombre si lo deseas):

```
python -m venv myenv
```

3. Activa el entorno virtual: A continuación, ejecuta el siguiente comando para activar el entorno virtual:

```
myenv\Scripts\activate
```

Linux y macOS:

1. Abre una terminal: Busca la aplicación "Terminal" en tu sistema operativo y ábrela.

2. Crea un nuevo entorno virtual: En la terminal, ejecuta el siguiente comando para crear un nuevo entorno virtual con el nombre "myenv" (puedes cambiar el nombre si lo deseas):

```
python3 -m venv myenv
```

3. Activa el entorno virtual: A continuación, ejecuta el siguiente comando para activar el entorno virtual:

```
source myenv/bin/activate
```

¡Listo! Ahora tienes un entorno virtual de Python creado y activado en tu sistema. Puedes instalar paquetes y trabajar en este entorno sin afectar tu instalación global de Python.

Recuerda que, una vez que hayas terminado de trabajar en el entorno virtual, puedes desactivarlo en cualquier momento ejecutando el siguiente comando:
```
deactivate
```

Espero que esta guía te sea útil. ¡Disfruta programando en Python en tu entorno virtual!

Cómo crear un entorno virtual en python

### Introducción
#### Crear directorio base y entorno virtual

Lo primero que vamos hacer es crear un directorio llamado `Duels`
que contendrá todo el código del proyecto. Lo segundo será abrir dicho directorio con nuestro editor de código y luego crear un  [entorno virtual](https://hol4mund0.vercel.app/raulodev/como-crear-un-entorno-virtual-en-python) y activarlo.

#### Instalar dependencias

Las documentaciones de las dependencias a instalar se encuentran en los siguientes enlaces :
* [docs.sqlalchemy.org](https://docs.sqlalchemy.org)
* [docs.python-telegram-bot.org](https://docs.python-telegram-bot.org/)
* [pypi.org/project/python-dotenv](https://pypi.org/project/python-dotenv/)

Comandos para instalar las dependencias con pip.
```console
pip install python-telegram-bot --upgrade
pip install SQLAlchemy
pip install python-dotenv
```

Crearemos un archivo **main.py** y pegaremos el siguiente código donde reemplazarás `YOUR TOKEN HERE` por el token de tu bot dado por [BotFather](https://t.me/BotFather).

```python
# main.py
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes


async def hello(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f'Hello {update.effective_user.first_name}')


app = ApplicationBuilder().token("YOUR TOKEN HERE").build()

app.add_handler(CommandHandler("hello", hello))

app.run_polling()
```
Antes de continuar comprobarás que el bot responda al comando `/hello` , para ejecutar nuestro código usarás el comando `python main.py` en la terminal , una vez llegado a este punto empezaremos a crear las funciones , modelos y configuración para nuestro bot.

### Empezando
#### Creando nuestro archivo de configuración.

Nuestro archivo de configuración se encargará de cargar todas las variables necesarias del entorno virtual y se almacenarán en una clase para facilitar el acceso a ellas desde cualquier parte del código.

Creamos un archivo **config.py** con el siguiente contenido:
```python
# config.py
import os
from dotenv import load_dotenv

load_dotenv()


class Config:
    # Get the bot token from the environment variable
    BOT_TOKEN = os.environ.get("BOT_TOKEN")
    # Get the database URL from the environment variable
    DATABASE_URL = os.environ.get("DATABASE_URL")
```

#### Variables de entorno
A continuación crearemos un archivo **.env** en la misma ruta que nuestro archivo main.py y config.py que almacenará cualquier dato que no debe ser compartido con nadie como por ejemplo el token de nuestro bot.

```js
# .env
BOT_TOKEN="123456789:ABCDEFabcdef"
DATABASE_URL="sqlite:///database.sqlite"
``` 

Actualizaremos nuestro archivo principal **main.py** para usar la clase Config:
```python
# main.py
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes
# nuevo
from config import Config


async def hello(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
    await update.message.reply_text(f"Hello {update.effective_user.first_name}")

# actualizado
app = ApplicationBuilder().token(Config.BOT_TOKEN).build()

app.add_handler(CommandHandler("hello", hello))

app.run_polling()
```

### Resumen

Primero que todo el código del proyecto se encontrará en el siguiente repositorio [duels](https://github.com/raulodev/duels)

Por el momento hemos creado nuestro entorno de desarrollo con las dependencias iniciales a utilizar .En el próximo capítulo crearemos los modelos de nuestra base de datos donde guardaremos los datos relacionados con los usuarios así como las estadísticas de victorias y derrotas para crear un ranking.

Creando un bot de duelos en Telegram

Vamos hacer una función de ejemplo llamada `iterar` escrita usando solamente python que tomará un argumento que corresponde con la cantidad de iteraciones que se realizarán:

```python
# example.py

def iterar(num: int):
    """
    Args:
        num (int): cantidad de iteraciones

    Returns:
        int: conteo final de las iteraciones realizadas
    """

    conteo = 0

    for n in range(num):
        conteo += 1

    return conteo


resultado = iterar(100)

print(resultado)  # salida: 100

```

En este ejemplo se pasa como argumento el número `100` obteniendo el resultado casi al instante pero cuando aumentamos la iteraciones a `99999999` o a un número mayor vemos que se tarda bastante tiempo y si el número es suficientemente grande puede incluso llegar a tardarse minutos en obtener el resultado.

### Aumentando la velocidad con c++
Para potenciar nuestro código python con c++ y que aumente la velocidad de respuesta en el caso que el número de iteraciones supere las `99999999`, vamos a crear un archivo llamado `iterar.cpp` con este contenido:

```cpp
// iterar.cpp


extern "C"
{
    // declarada la función iterar como una función externa de C.
    int iterar(int num)
    {
        int conteo = 0;
        for (int i = 0; i < num; i++)
        {
            conteo++;
        };

        return conteo;
    }
}
```

Entonces una vez que compilemos este código con el siguiente comando obtendremos un archivo de biblioteca compartida (DLL en Windows o SO en Linux) :

```console
$ g++ -shared -o iterar.so  iterar.cpp
```

### Utilizando la biblioteca compartida

Después de compilar el código y generar la biblioteca compartida, puedes utilizar el siguiente código de Python para cargar y utilizar la biblioteca compartida utilizando ctypes. 

```python
# iterar.py

import ctypes

# Cargamos la biblioteca compartida
lib = ctypes.CDLL("./iterar.so")  # Ruta a la biblioteca compartida

# Definimos los tipos de argumentos y el tipo de retorno de la función
lib.iterar.argtypes = (ctypes.c_int ,)
lib.iterar.restype = ctypes.c_int

# Llamamos a la función iterar y obtenemos el resultado
result = lib.iterar(99999999)
print(result)  # Salida: 99999999
```

Ahora esta vez cuando ejecutemos nuestro código python y pasemos como argumento un número tal como `99999999` el resultado se obtendrá muchísimo antes que si utilizáramos solamente código python.

Liberar Espacio en un VPS con Linux

Reportar publicación

Eliminar publicación

Cómo listar y cambiar entre versiones de Java en Linux

Reportar publicación

Eliminar publicación

Descargar videos de youtube desde la terminal linux

Reportar publicación

Eliminar publicación

Configurando servidor de correo local para fines de pruebas y desarrollo

Reportar publicación

Eliminar publicación

Copiar los datos de una base de datos PostgreSQL a otra alojadas en diferentes contenedores docker

Reportar publicación

Eliminar publicación

Explorando las Operaciones Ternarias en Python: Concisión y Elegancia

Reportar publicación

Eliminar publicación

Cómo crear un entorno virtual en python

Reportar publicación

Eliminar publicación

Creando un bot de duelos en Telegram

Reportar publicación

Eliminar publicación

Haz que tu código python sea más rápido con c++

Reportar publicación

Eliminar publicación