Gestionar objetos con AWS CLI

El encargo y el lugar de cada herramienta

La asociación ya ha gestionado sus avisos desde la consola web. Ahora necesita subir y recuperar un archivo desde la terminal y demostrar que ambas interfaces acceden al mismo objeto. Trabaja individualmente con un bucket privado para esta práctica.

Las órdenes aws realizan peticiones a las API de AWS; no abren una sesión interactiva dentro de la consola web. El vídeo del curso muestra listado y copia, pero aquí utilizarás las credenciales temporales del laboratorio, sin crear un usuario IAM administrador ni descargar claves permanentes.

El anfitrión Windows o Linux ejecuta Docker, el navegador y el editor local. Los comandos de shell y AWS CLI se ejecutan dentro del Debian de P00, como alumno. El perfil temporal se guarda en su directorio personal, no en la carpeta compartida.

Si todavía no tienes el bucket, créalo

Utilizarás un bucket llamado aws-s3-cli-XXXXXXXX. Sustituye XXXXXXXX por ocho letras minúsculas o números que elijas. Si ya lo creaste para esta práctica, comprueba su configuración y continúa con el apartado siguiente.

1. Activa Learner Lab con Start Lab y abre la consola de AWS. Anota el saldo y el tiempo disponibles.
2. Entra en S3 → Buckets → Create bucket (Crear bucket).
3. Selecciona la región US East (N. Virginia), us-east-1, y el tipo General purpose. Si aparece la opción de espacio de nombres, elige Shared global namespace.
4. Escribe el nombre elegido, por ejemplo aws-s3-cli-a7b2c9d4. Si ya está ocupado, cambia las ocho letras o números y vuelve a intentarlo.
5. Mantén ACLs disabled / Bucket owner enforced y las cuatro opciones de Block Public Access activadas. El bucket debe ser privado.
6. Deja el versionado deshabilitado, el cifrado SSE-S3 y Object Lock deshabilitado. No añadas una política pública ni claves KMS.
7. Pulsa Create bucket. Ábrelo y comprueba que la pestaña Objects está vacía. No necesitas subir ningún archivo todavía: lo harás desde la terminal.

Guarda el nombre exacto del bucket: lo introducirás más adelante en la terminal. Regístralo en tu inventario de recursos. Esta práctica utiliza archivos de texto pequeños y unas pocas transferencias; revisa el saldo también al terminar.

Entrar en Debian y preparar AWS CLI

En la terminal del anfitrión, ejecuta estas dos órdenes. La segunda entra en el contenedor persistente con usuario, directorio y HOME explícitos:

docker start p00-lab
docker exec -it --user alumno --workdir /home/alumno --env HOME=/home/alumno p00-lab bash

La orden larga se lee así: «abre Bash dentro de p00-lab, como alumno, situado en su carpeta personal y con ese mismo directorio como HOME».

Parte	Qué significa
docker exec	Ejecuta un programa dentro de un contenedor que ya está en marcha.
-it	Combina -i, para poder introducir órdenes, y -t, para disponer de una terminal interactiva.
--user alumno	Ejecuta el programa como el usuario alumno.
--workdir /home/alumno	Sitúa inicialmente la terminal en esa carpeta dentro del contenedor.
--env HOME=/home/alumno	Indica a los programas cuál es tu directorio personal en esta sesión. AWS CLI buscará allí la carpeta .aws. No cambia por sí solo el usuario.
p00-lab	Nombre del contenedor en el que se ejecuta el programa.
bash	Programa que abre la shell donde escribirás las siguientes órdenes.

--workdir decide dónde empiezas a trabajar; HOME indica dónde está tu carpeta personal aunque después cambies de directorio con cd. Por eso especificamos ambos. Esta orden abre otra shell dentro del contenedor; no crea un contenedor nuevo.

A partir de aquí estás dentro de Debian. Compruébalo antes de instalar o crear archivos:

whoami
pwd
echo $HOME

Debes obtener alumno, /home/alumno y /home/alumno. Si no coinciden, revisa la entrada; no uses la cuenta root para guardar las credenciales. Si Docker no puede conectar con su motor, vuelve al anfitrión y comprueba que Docker esté funcionando.

Vamos a instalar AWS CLI (cliente aws) y nano (editor).

sudo apt-get update
sudo apt-get install --yes --no-install-recommends awscli nano
aws --version

apt-get update consulta el catálogo y install añade paquetes al contenedor. Esta instalación no cambia el Dockerfile ni crea una nueva imagen: permanece en este contenedor mientras lo conserves.

Punto de control: el comando aws existe dentro de Debian. Que exista en el anfitrión no comprueba esta instalación.

Preparar las credenciales temporales sin publicarlas

1. Activa Learner Lab y abre sus detalles, habitualmente AWS Details y el bloque de credenciales para CLI. Copiarás los tres valores del mismo juego temporal.
2. Dentro de Debian, retira selecciones de otras prácticas de esta shell sin mostrar su contenido. unset elimina variables de la sesión, no los archivos de configuración:

unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN AWS_SECURITY_TOKEN
unset AWS_PROFILE AWS_DEFAULT_PROFILE AWS_CONFIG_FILE AWS_SHARED_CREDENTIALS_FILE
unset AWS_ENDPOINT_URL AWS_ENDPOINT_URL_S3 AWS_ENDPOINT_URL_STS

3. Prepara el archivo privado. umask 077 restringe los permisos de los nuevos archivos; touch crea el archivo si falta sin vaciar uno existente. No borres otros perfiles:

umask 077
mkdir -p "$HOME/.aws"
chmod 700 "$HOME/.aws"
touch "$HOME/.aws/credentials"
chmod 600 "$HOME/.aws/credentials"
nano "$HOME/.aws/credentials"

4. En el editor, añade o renueva únicamente la sección [learnerlab]. Si el bloque del laboratorio se llama [default], cambia esa cabecera. El siguiente fragmento muestra la estructura: sustituye los textos por los valores temporales reales solo dentro del editor:

[learnerlab]
aws_access_key_id = VALOR_TEMPORAL_DEL_LABORATORIO
aws_secret_access_key = SECRETO_DEL_MISMO_JUEGO
aws_session_token = TOKEN_DEL_MISMO_JUEGO

Guarda con Ctrl+O, confirma el nombre y sal con Ctrl+X. No pegues estos valores en órdenes, scripts o un heredoc; tampoco muestres el archivo con cat. El editor evita introducirlos en el historial de órdenes, pero el archivo sigue siendo sensible y no está cifrado por tener permisos restrictivos.

El asistente habitual aws configure no pide el token de sesión. Por eso no basta para completar este acceso temporal. Si las credenciales vencen, renueva los tres valores juntos desde el laboratorio activo.

Configura únicamente región y formato con estas órdenes, que no incluyen secretos:

aws configure set region us-east-1 --profile learnerlab
aws configure set output json --profile learnerlab

aws configure set significa guardar un valor de configuración. Después de set escribes el nombre del ajuste y su valor:

Fragmento	Qué guarda
set region us-east-1	Establece us-east-1 como región predeterminada para ese perfil. No crea recursos ni mueve buckets existentes.
set output json	Establece JSON como formato de salida de las operaciones que admiten ese formato. Cambia cómo se presenta la respuesta, no el contenido de tus archivos.
--profile learnerlab	Guarda el ajuste para el perfil llamado learnerlab, el mismo que utiliza las credenciales temporales.

Estos dos ajustes se guardan en ~/.aws/config y se conservan al cerrar la terminal. Por ejemplo, JSON organiza una respuesta mediante nombres y valores, como "Account": "...". No todas las órdenes muestran JSON: aws s3 ls tiene su propio listado de texto.

En las siguientes órdenes seguiremos indicando --region us-east-1 para hacer visible la región elegida. Ese argumento se aplica a la llamada concreta y tiene prioridad sobre la región predeterminada del perfil. No es necesario volver a ejecutar configure set antes de cada transferencia.

Antes de operar con S3, comprueba qué identidad está utilizando CLI, sin entregar ni capturar su salida:

aws --profile learnerlab --region us-east-1 sts get-caller-identity --no-cli-pager

Esta orden pregunta a AWS: «¿con qué identidad estoy haciendo esta petición?» Se descompone así:

Parte	Para qué sirve
aws	Ejecuta AWS CLI.
--profile learnerlab	Selecciona las credenciales y los ajustes de ese perfil.
--region us-east-1	Indica la región utilizada para la petición.
sts	Selecciona AWS Security Token Service, el servicio de identidad y credenciales temporales.
get-caller-identity	Solicita los datos de la identidad que realiza la llamada. No crea un usuario ni cambia permisos.
--no-cli-pager	Muestra la respuesta directamente en la terminal, sin abrir un visor de páginas. No significa «sin paginar los resultados de AWS».

La respuesta contiene Account, identificador de la cuenta; Arn, identificador del usuario o sesión de rol; y UserId, identificador de esa identidad. En Learner Lab se utiliza una identidad temporal; no esperes que aparezca un usuario IAM que hayas creado tú.

Compara localmente Account con la cuenta del laboratorio. Una respuesta correcta indica que AWS reconoce las credenciales usadas en esa petición; todavía no demuestra que puedas listar, subir o borrar objetos de S3. No la incluyas en tu bitácora. No atribuyas a End Lab una revocación inmediata garantizada del token.

Indicar en la terminal qué bucket vas a utilizar

En Debian, escribe el nombre completo de tu bucket en esta asignación. Sustituye el nombre del ejemplo por el que aparece en tu consola:

BUCKET="aws-s3-cli-a7b2c9d4"

Has creado una variable de la shell llamada BUCKET y has guardado en ella el nombre del bucket. No has creado un bucket nuevo en AWS: solo has guardado un texto en la terminal para reutilizarlo en las siguientes llamadas.

Escribe la asignación sin espacios alrededor de =. Para guardar el valor utilizas BUCKET; para recuperarlo escribes $BUCKET. Compruébalo:

echo "$BUCKET"

Debe mostrar exactamente el nombre de tu bucket. La expresión "s3://$BUCKET/" se convertirá en una dirección como s3://aws-s3-cli-a7b2c9d4/ antes de que la reciba AWS CLI. Las comillas dobles permiten sustituir la variable por su valor.

La variable solo existe en esta sesión de terminal. Si sales y vuelves a entrar, tendrás que definirla de nuevo. Si prefieres no utilizarla, puedes escribir el nombre completo en cada dirección S3: verás ejemplos de ambas formas a continuación. Son alternativas; no necesitas ejecutar cada operación dos veces.

Listar, subir y descargar un archivo

Prepara un directorio nuevo. mkdir -p crea las carpetas necesarias y cd cambia el punto de trabajo. Si ya existe un aviso-cli.txt de otra ejecución, revísalo antes de la redirección >, que sustituye su contenido:

mkdir -p /optativa-nube/aws-s3/cli/recuperados
cd /optativa-nube/aws-s3/cli
printf 'Jornada de herramientas en la nube\nArchivo ficticio transferido mediante CLI\nRevision: 1\n' > aviso-cli.txt

También tienes el archivo de partida. El texto anterior permite construirlo aunque no puedas descargarlo. Ábrelo o consulta con cat aviso-cli.txt: es un archivo ficticio, no un archivo de credenciales.

Lista los buckets y, después, el contenido de tu destino:

aws --profile learnerlab --region us-east-1 s3 ls
aws --profile learnerlab --region us-east-1 s3 ls "s3://$BUCKET/"

En la segunda orden, $BUCKET se sustituye por el nombre que guardaste. Sin variable, el mismo listado se escribiría así, cambiando el nombre del ejemplo por el tuyo:

aws --profile learnerlab --region us-east-1 s3 ls "s3://aws-s3-cli-a7b2c9d4/"

La primera orden enumera buckets y necesita un permiso distinto de listar objetos. Una denegación en esa consulta no demuestra que fallen todas las operaciones S3: registra el resultado y comprueba el destino concreto. Un listado vacío del bucket con finalización correcta es normal antes de la carga; no confundas silencio y error.

cp significa copia. El primer argumento es el origen y el segundo, el destino. Sube el aviso a una clave conocida:

aws --profile learnerlab --region us-east-1 s3 cp aviso-cli.txt "s3://$BUCKET/aviso-cli.txt"
aws --profile learnerlab --region us-east-1 s3 ls "s3://$BUCKET/"

La orden de subida sin variable sería:

aws --profile learnerlab --region us-east-1 s3 cp aviso-cli.txt "s3://aws-s3-cli-a7b2c9d4/aviso-cli.txt"

En ambos casos, el origen es el archivo local y el destino es el objeto del bucket. Recuerda utilizar tu nombre real.

Actualiza Objects en la consola: debe aparecer la misma clave, aviso-cli.txt, como objeto Standard. No has hecho público el archivo ni eliminado el original local.

Descarga aviso-cli.txt desde el bucket a la carpeta local recuperados/. Así conservas el archivo original y puedes compararlo con la copia descargada. Ejecuta estas dos órdenes: la primera descarga el archivo y la segunda compara su contenido con el original.

aws --profile learnerlab --region us-east-1 s3 cp "s3://$BUCKET/aviso-cli.txt" recuperados/aviso-cli.txt

diff aviso-cli.txt recuperados/aviso-cli.txt

La descarga sin variable se escribiría así, sustituyendo de nuevo el nombre:

aws --profile learnerlab --region us-east-1 s3 cp "s3://aws-s3-cli-a7b2c9d4/aviso-cli.txt" recuperados/aviso-cli.txt

Aquí el origen es S3 y el destino es local: la posición de los argumentos determina el sentido de la copia.

diff compara los archivos de texto. Si no muestra diferencias y termina correctamente, el contenido coincide. Si las muestra, lee qué líneas cambian y revisa qué copia abriste. No basta con que ambos archivos tengan el mismo nombre.

Ejercicio: borrar un objeto de S3 y recuperarlo con el versionado

Vas a borrar un archivo del equipo y su objeto de S3. Después recuperarás primero el objeto en S3, retirando su marcador de borrado, y luego el archivo en el equipo, descargándolo. Son dos operaciones distintas.

Trabaja individualmente dentro del Debian de P00, como alumno, con el mismo bucket de esta práctica. Sigue el orden y comprueba el resultado de cada paso antes de continuar. No necesitas crear otro bucket.

Paso 1. Preparar la sesión y comprobar el bucket

Activa Start Lab y comprueba que el laboratorio está en marcha. Las credenciales deben estar vigentes en [learnerlab], como has preparado al principio de esta página. Selecciona ese perfil para esta terminal y evita que CLI intente abrir el visor less:

export AWS_PROFILE=learnerlab
export AWS_PAGER=""
aws configure get region
aws sts get-caller-identity

AWS_PROFILE permite usar learnerlab sin repetir --profile learnerlab en cada orden de este ejercicio. AWS_PAGER vacío muestra las respuestas directamente. Estos ajustes solo afectan a esta sesión; no crean ni borran perfiles. La región debe ser us-east-1. Consulta la identidad localmente, sin capturar ni entregar su respuesta.

Comprueba el destino:

echo "$BUCKET"

Debe mostrar el nombre completo de tu bucket, sin s3://. Si está vacío o no corresponde, vuelve a definirlo con tu nombre real:

BUCKET="NOMBRE_COMPLETO_DE_TU_BUCKET"

No ejecutes las siguientes órdenes dejando el texto de ejemplo como nombre. A partir de aquí todas usan esa misma variable.

Paso 2. Habilitar el versionado antes de subir el archivo

En la consola, abre tu bucket → Properties / Propiedades → Bucket Versioning / Control de versiones → Edit. Habilita el versionado y guarda. Mantén las cuatro BPA activas y las ACL deshabilitadas.

Comprueba desde CLI:

aws s3api get-bucket-versioning --bucket "$BUCKET"

Debe aparecer:

{
  "Status": "Enabled"
}

Si acabas de habilitarlo por primera vez, espera al menos quince minutos antes de subir o borrar objetos. Puedes preparar el archivo local durante esa espera. Si ya estaba habilitado y ese tiempo había transcurrido, no necesitas esperar otros quince minutos. Recomendación de AWS.

El versionado no reconstruye archivos borrados antes de su activación. Para esta prueba subiremos un objeto nuevo después de habilitarlo.

Paso 3. Crear el archivo local y fijar su nombre exacto

Prepara la carpeta y entra en ella:

mkdir -p /optativa-nube/aws-s3/cli/ejercicios/recuperacion
cd /optativa-nube/aws-s3/cli/ejercicios/recuperacion
nano aviso-perdido.txt

Escribe estas dos líneas, guarda y sal del editor:

Actividad: taller de nube
Lugar: aula 2

Comprueba el archivo:

ls
cat aviso-perdido.txt

Utilizaremos siempre aviso-perdido.txt, no archivo-perdido.txt. La ubicación local es la carpeta actual; la clave que tendrá en S3 será recuperacion/aviso-perdido.txt. Copia los nombres del enunciado para evitar diferencias de letras o prefijos.

Paso 4. Subir y confirmar una versión con datos

Una vez transcurrida la espera inicial, sube el archivo:

aws s3 cp aviso-perdido.txt "s3://$BUCKET/recuperacion/aviso-perdido.txt"
aws s3 ls "s3://$BUCKET/recuperacion/"

La primera orden copia el archivo local a S3. La segunda debe mostrar aviso-perdido.txt. Consulta también su historial:

aws s3api list-object-versions --bucket "$BUCKET" --prefix recuperacion/aviso-perdido.txt

aws s3api ofrece operaciones específicas de S3, como consultar versiones. En esta orden, --bucket recibe solo el nombre del bucket y --prefix selecciona claves que empiezan por ese texto.

Debes encontrar dentro de Versions una entrada de la clave exacta con un identificador. Este es un ejemplo simplificado; tu VersionId será diferente:

{
  "Versions": [
    {
      "Key": "recuperacion/aviso-perdido.txt",
      "VersionId": "ID_DE_LA_VERSION_CON_DATOS",
      "IsLatest": true
    }
  ]
}

No avances al borrado hasta ver esa versión. Prefix solo repite el filtro solicitado: no demuestra que el archivo exista. Una respuesta sin Versions ni DeleteMarkers no contiene entradas recuperables para esa búsqueda. RequestCharged: null, si aparece, tampoco confirma una recuperación.

Si no encuentras el objeto, lista sus claves reales:

aws s3 ls "s3://$BUCKET/" --recursive

Compara el nombre y la ruta con los utilizados al subirlo. Si aparece aviso-perdido.txt en la raíz y no bajo recuperacion/, las claves son distintas. Corregir la búsqueda no requiere borrar nada.

Paso 5. Borrar la copia local y hacer un borrado normal en S3

Primero elimina únicamente el archivo local, desde la carpeta del paso 3:

rm -i aviso-perdido.txt
ls

Lee el nombre que pregunta rm -i y confirma según el idioma de la terminal. El archivo ya no debe aparecer en ese listado local. No has solicitado todavía un borrado a AWS.

Ahora solicita una sola vez el borrado normal del objeto de S3:

aws s3 rm "s3://$BUCKET/recuperacion/aviso-perdido.txt"
aws s3 ls "s3://$BUCKET/recuperacion/"

El listado normal ya no debe mostrarlo. Como el bucket tiene versionado, S3 conserva la versión con datos y añade encima un marcador de borrado. No repitas aws s3 rm: podrías añadir más marcadores.

Paso 6. Encontrar el identificador del marcador correcto

Consulta otra vez el historial con la misma clave:

aws s3api list-object-versions --bucket "$BUCKET" --prefix recuperacion/aviso-perdido.txt

Ahora debes distinguir dos grupos. Ejemplo simplificado:

{
  "Versions": [
    {
      "Key": "recuperacion/aviso-perdido.txt",
      "VersionId": "ID_DE_LA_VERSION_CON_DATOS",
      "IsLatest": false
    }
  ],
  "DeleteMarkers": [
    {
      "Key": "recuperacion/aviso-perdido.txt",
      "VersionId": "ID_DEL_MARCADOR_DE_BORRADO",
      "IsLatest": true
    }
  ]
}

Lo que ves	Qué significa	Qué haces ahora
Versions	Versiones que conservan el contenido.	No las elimines.
DeleteMarkers	Marcadores que hacen que el objeto parezca borrado.	Localiza el de tu clave exacta con IsLatest: true.
Key	Nombre completo del objeto, incluido el prefijo.	Comprueba recuperacion/aviso-perdido.txt.
VersionId dentro de ese marcador	Identificador de la entrada que hay que retirar.	Copia su valor, sin las comillas exteriores del JSON.
Owner → ID	Identificador del propietario.	No lo copies: no identifica el marcador.

Selecciona únicamente el VersionId dentro de DeleteMarkers, para la clave exacta y con IsLatest: true. La versión con datos y el marcador tienen identificadores distintos. Si no aparecen los dos grupos esperados o hay varios marcadores de intentos anteriores, revisa el historial antes de continuar; no borres identificadores al azar.

Paso 7. Retirar solo el marcador

En la siguiente orden, sustituye el texto de ejemplo por el identificador real que acabas de copiar, conservando las comillas:

aws s3api delete-object --bucket "$BUCKET" --key recuperacion/aviso-perdido.txt --version-id "PEGA_AQUI_EL_VERSION_ID_DEL_MARCADOR"

Se lee así: «en este bucket, para esta clave, elimina únicamente la entrada con este identificador». No necesitas crear una variable adicional porque solo usas el identificador una vez.

El comando se llama delete-object, pero aquí recuperamos el acceso eliminando el marcador, no la versión con datos. Si eligieras el identificador de Versions, borrarías permanentemente esa versión. Si omitieras --version-id, podrías añadir otro marcador.

La respuesta de una retirada correcta puede tener esta forma simplificada:

{
  "DeleteMarker": true,
  "VersionId": "ID_DEL_MARCADOR_QUE_HAS_RETIRADO"
}

Este JSON confirma la operación sobre el marcador. No descarga el archivo al ordenador ni basta por sí solo para dar la recuperación por terminada. Continúa con la comprobación del paso siguiente.

Paso 8. Comprobar que el objeto ha vuelto a ser visible en S3

aws s3 ls "s3://$BUCKET/recuperacion/"

Debe reaparecer aviso-perdido.txt sin volver a subirlo. La versión con datos que estaba debajo del marcador vuelve a ser la actual.

Si no aparece, consulta de nuevo el historial. Comprueba la clave y si queda otro marcador actual de un intento anterior. No repitas automáticamente la orden del paso 7: el marcador retirado ya no existe. Si no queda ninguna versión con datos, retirar marcadores no puede reconstruir su contenido.

Volver a subir el archivo crearía una copia nueva; no demostraría haber recuperado la versión anterior.

Paso 9. Descargar el objeto recuperado al equipo

Sigue dentro de la carpeta local del paso 3. Comprueba primero que no existe allí un archivo de otro intento que no quieras sobrescribir. Después descarga desde S3:

aws s3 cp "s3://$BUCKET/recuperacion/aviso-perdido.txt" aviso-perdido.txt
ls
cat aviso-perdido.txt

En esta copia, el primer argumento es el origen S3 y el segundo el nombre local. cat debe mostrar:

Actividad: taller de nube
Lugar: aula 2

Ahora has comprobado las dos recuperaciones: visible otra vez en S3 y descargado de nuevo al equipo con su contenido correcto. No utilices diff contra el original que eliminaste; aquí comparas las líneas con el texto conocido del enunciado.

Si aparece un error durante la recuperación

Síntoma	Cómo comprobarlo y continuar
Error de visor: no existe less	Ejecuta export AWS_PAGER="". Si el error apareció después de un borrado, comprueba el estado remoto antes de repetirlo: AWS puede haber realizado ya la operación.
AccessDenied al listar versiones	Comprueba que Learner Lab siga activo y el bucket sea correcto. La consulta requiere s3:ListBucketVersions. Si persiste con sesión vigente, registra el bloqueo; no cambies IAM ni hagas público el bucket.
ExpiredToken	Reactiva el laboratorio si corresponde y renueva las tres credenciales del perfil utilizado. No repitas borrados sin consultar antes el historial.
Respuesta sin Versions ni DeleteMarkers	Comprueba el bucket y la clave exacta mediante el listado recursivo. aviso-perdido.txt y archivo-perdido.txt no son el mismo objeto.
Respuesta de borrado con VersionId, pero falta el archivo local	Comprueba primero el listado S3; si el objeto reapareció, todavía debes descargarlo con cp.
Aparece DeleteMarker: false tras borrar una entrada específica	Puede haberse eliminado una versión con datos. Detente y revisa qué versiones quedan antes de borrar nada más.

A entregar

Registra las órdenes utilizadas y los resultados que muestran la secuencia: versión con datos antes del borrado, marcador actual después, objeto visible al retirarlo y contenido descargado. Explica con tus palabras por qué borrar el marcador permite recuperar el objeto. Oculta datos de cuenta y usa un alias para el identificador en las capturas o transcripciones; no incluyas credenciales ni respuestas completas con datos personales.

Conserva el bucket para el ejercicio siguiente. Al terminar ambos, aplica la limpieza del final de esta página, incluyendo todas las versiones y marcadores.

Ejercicio: organizar un pequeño archivo digital

Ahora la asociación quiere separar sus avisos y sus manuales. Organizarás los objetos mediante prefijos y comprobarás que el nombre de la copia descargada puede ser distinto del de la clave S3.

Trabaja individualmente con el mismo bucket privado, que ahora tiene el versionado habilitado. Las cargas de objetos nuevos también tendrán identificadores de versión. En Debian, prepara las carpetas locales:

mkdir -p /optativa-nube/aws-s3/cli/ejercicios/archivo/avisos
mkdir -p /optativa-nube/aws-s3/cli/ejercicios/archivo/manuales
mkdir -p /optativa-nube/aws-s3/cli/ejercicios/archivo/descargas
cd /optativa-nube/aws-s3/cli/ejercicios/archivo

1. Crea con nano estos tres archivos. Cada contenido ocupa una línea; conserva los originales para poder compararlos después.

Archivo local	Contenido ficticio	Clave que debe tener en S3
avisos/horario.txt	Horario del taller: 10:00	avisos/horario.txt
manuales/acceso.txt	Acceso al taller: puerta 2	manuales/acceso.txt
manuales/seguridad.txt	Utiliza solo documentos ficticios	manuales/seguridad.txt

2. Sube cada archivo con una orden aws s3 cp, indicando su origen local y la clave de destino de la tabla. No necesitas sync, copias recursivas ni crear carpetas previamente en S3.
3. Lista por separado s3://$BUCKET/avisos/ y s3://$BUCKET/manuales/ con AWS CLI. El primero debe contener un objeto y el segundo dos. Estos listados no deben incluir el objeto de recuperacion/ del ejercicio anterior.
4. Descarga con CLI avisos/horario.txt a descargas/agenda-recuperada.txt y manuales/acceso.txt a descargas/guia-acceso.txt. Escribe un nombre de archivo completo en el destino local de cada copia.
5. Usa diff para comparar cada descarga con su original local, aunque sus nombres sean distintos. Indica los dos pares que comparaste y el resultado.
6. Comprueba en la consola que los tres objetos siguen teniendo las claves de la tabla. Descargar con otro nombre no cambia la clave del objeto remoto.

A entregar: las dos órdenes de listado con sus resultados, las dos órdenes de descarga, el resultado de las comparaciones y una frase que distinga prefijo S3, carpeta local y nombre de la descarga. Utiliza alias para el bucket y excluye cabeceras de cuenta y credenciales. Reúne los dos ejercicios en la bitácora común; no necesitas un informe por cada orden.

Si algo falla

Síntoma	Comprobación antes de repetir
aws: command not found	Comprueba que estás en Debian y que terminó la instalación allí.
Perfil inexistente o credenciales no localizadas	Revisa usuario, HOME y cabecera [learnerlab] sin mostrar secretos.
Token inválido, vencido o fallo de autenticación	Renueva juntos los tres valores temporales; comprueba sesión y reloj.
AccessDenied en una operación	Identifica si falla identidad, listado de buckets o acción sobre el objeto. No crees usuarios ni añadas permisos públicos.
Archivo local no encontrado	Ejecuta pwd y ls; las rutas locales se interpretan dentro del contenedor.
Error de bucket o endpoint	Compara la variable, la región y el bucket real en consola.

Una orden fallida se registra como tal. No publiques la salida completa de una consulta de identidad para explicar la incidencia.

Limpiar y A entregar

1. En la consola, revisa el nombre del bucket propio. Ahora tiene versionado: eliminar solo los objetos visibles no lo vacía. Activa Show versions / Mostrar versiones y revisa todas las versiones y marcadores de esta práctica: aviso-cli.txt, recuperacion/aviso-perdido.txt, avisos/horario.txt, manuales/acceso.txt y manuales/seguridad.txt, además de posibles intentos adicionales. Elimina permanentemente esas entradas; comprueba que no seleccionas datos ajenos. Puedes usar Empty / Vaciar sobre este bucket exclusivo de práctica, comprobando que incluye versiones y marcadores y leyendo la confirmación de borrado permanente.
2. Verifica que no quedan versiones ni marcadores, elimina el bucket y actualiza el inventario: debe estar ausente. No uses aws s3 rm --recursive como prueba de limpieza completa de un bucket versionado. Si hay Object Lock, retenciones o permisos insuficientes, registra lo pendiente sin afirmar que está limpio.
3. En el editor privado, retira las tres entradas temporales de la sección [learnerlab] cuando hayas terminado de usarlas, conservando otros perfiles. No copies el archivo para entregarlo. La región y el formato de ~/.aws/config no son secretos y pueden conservarse.
4. Registra saldo o actualización pendiente y pulsa End Lab si termina la sesión. Limpia el portapapeles copiando un texto inocuo.
5. Si termina tu trabajo, sal de Debian con exit. En el anfitrión, detén el contenedor persistente:

docker stop p00-lab
docker ps -a --filter 'name=^/p00-lab$'

Debe figurar como Exited. Salir de la shell de docker exec no detiene su proceso principal. Si continúas directamente con la siguiente práctica, puedes mantener la sesión y las herramientas activas, pero elimina este bucket igualmente; la siguiente creará otro.

En la bitácora común incluye versión de CLI, región, resultado de ambos listados, carga/descarga y comparación del ejemplo guiado, los productos indicados en los dos ejercicios finales, incidencia si hubo y limpieza. Usa alias para los recursos y escribe «coincide» o el contenido comprobado: no entregues credenciales, salida de identidad, rutas con firmas ni registros completos. Puedes usar un recorte de Objects como comprobación, sin cabecera de cuenta.

Fuentes: docker exec, configure set, consulta de identidad STS, credenciales y perfiles, CLI en Debian trixie, recuperación con marcadores, list-object-versions, delete-object, s3 ls y s3 cp.