Passerelle S3 privée entre baleine et gros chat

aws --profile groschat s3 ls s3://mab-documents

# Résultat attendu
# 2026-05-28 ... fifi.txt
# 2026-05-28 ... loulou.txt
# 2026-05-28 ... riri.txt

# Desired : nombre de tasks demandées par le service.
# Running : nombre de tasks réellement en fonctionnement.
# Pending : nombre de tasks en cours de démarrage.
# Si Desired=1, Running=1, Pending=0, la passerelle est stable.
aws --profile groschat ecs describe-services   --cluster rclone-s3-gateway-cluster   --services rclone-s3-gateway-service   --query 'services[0].{Desired:desiredCount,Running:runningCount,Pending:pendingCount,Status:status}'   --output table

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListBucket",
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::mab-documents"
    },
    {
      "Sid": "ReadObjects",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::mab-documents/*"
    }
  ]
}

aws --profile baleine secretsmanager create-secret   --name poc/s3-gateway/groschat/mab-documents   --secret-string '{
    "AWS_ACCESS_KEY_ID": "<LOCAL_ACCESS_KEY>",
    "AWS_SECRET_ACCESS_KEY": "<LOCAL_SECRET_KEY>",
    "ENDPOINT_URL": "http://<PRIVATE_LINK_DNS>:8080",
    "REGION": "eu-west-3",
    "BUCKET": "mab-documents"
  }'

[mabaws]
type = s3
provider = AWS
env_auth = true
region = eu-west-3
location_constraint = eu-west-3

[gateway]
type = combine
upstreams = mab-documents=mabaws:mab-documents

FROM rclone/rclone:latest

COPY rclone.conf /config/rclone/rclone.conf

EXPOSE 8080

ENTRYPOINT ["rclone"]
CMD ["serve", "s3", "gateway:", "--addr", ":8080", "--auth-key", "<LOCAL_ACCESS_KEY>,<LOCAL_SECRET_KEY>", "--vfs-cache-mode", "off", "-vv"]

FROM rclone/rclone:latest

COPY rclone.conf /config/rclone/rclone.conf

EXPOSE 8080

ENTRYPOINT ["rclone"]
CMD ["serve", "s3", "gateway:", "--addr", ":8080", "--auth-key", "<LOCAL_ACCESS_KEY>,<LOCAL_SECRET_KEY>", "--vfs-cache-mode", "off", "-vv"]

docker build -t rclone-s3-gateway:latest .

docker tag rclone-s3-gateway:latest   <ACCOUNT_GROSCHAT>.dkr.ecr.eu-west-3.amazonaws.com/rclone-s3-gateway:latest

aws --profile groschat ecr get-login-password --region eu-west-3   | docker login       --username AWS       --password-stdin <ACCOUNT_GROSCHAT>.dkr.ecr.eu-west-3.amazonaws.com

docker push <ACCOUNT_GROSCHAT>.dkr.ecr.eu-west-3.amazonaws.com/rclone-s3-gateway:latest

aws --profile groschat ecs update-service   --cluster rclone-s3-gateway-cluster   --service rclone-s3-gateway-service   --force-new-deployment

aws --profile groschat ecs wait services-stable   --cluster rclone-s3-gateway-cluster   --services rclone-s3-gateway-service

{
  "family": "rclone-s3-gateway",
  "networkMode": "awsvpc",
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "512",
  "memory": "1024",
  "executionRoleArn": "arn:aws:iam::<ACCOUNT_GROSCHAT>:role/ecsTaskExecutionRole",
  "taskRoleArn": "arn:aws:iam::<ACCOUNT_GROSCHAT>:role/rclone-s3-gateway-task-role",
  "containerDefinitions": [
    {
      "name": "rclone-s3-gateway",
      "image": "<ACCOUNT_GROSCHAT>.dkr.ecr.eu-west-3.amazonaws.com/rclone-s3-gateway:latest",
      "portMappings": [{ "containerPort": 8080, "protocol": "tcp" }]
    }
  ]
}

# Ces endpoints ne sont pas consommés par baleine.
# Ils servent à faire tourner Fargate dans des subnets privés, sans NAT Gateway.

# 1. Gateway Endpoint S3 : accès privé au bucket S3 réel.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.s3   --vpc-endpoint-type Gateway   --route-table-ids <ROUTE_TABLE_GROSCHAT>   --tag-specifications 'ResourceType=vpc-endpoint,Tags=[{Key=Name,Value=poc-s3-gateway-s3-endpoint}]'

# 2. Interface Endpoint ECR API : accès privé à l’API ECR.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.ecr.api   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_GROSCHAT_A> <SUBNET_GROSCHAT_B>   --security-group-ids <SG_ENDPOINTS_AWS>   --private-dns-enabled   --tag-specifications 'ResourceType=vpc-endpoint,Tags=[{Key=Name,Value=poc-s3-gateway-ecr-api-endpoint}]'

# 3. Interface Endpoint ECR DKR : accès privé au registry Docker ECR.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.ecr.dkr   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_GROSCHAT_A> <SUBNET_GROSCHAT_B>   --security-group-ids <SG_ENDPOINTS_AWS>   --private-dns-enabled   --tag-specifications 'ResourceType=vpc-endpoint,Tags=[{Key=Name,Value=poc-s3-gateway-ecr-dkr-endpoint}]'

# 4. Interface Endpoint CloudWatch Logs : envoi privé des logs de la task.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.logs   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_GROSCHAT_A> <SUBNET_GROSCHAT_B>   --security-group-ids <SG_ENDPOINTS_AWS>   --private-dns-enabled   --tag-specifications 'ResourceType=vpc-endpoint,Tags=[{Key=Name,Value=poc-s3-gateway-logs-endpoint}]'

# 5. Côté gros chat : publier le NLB interne comme Endpoint Service PrivateLink.
SERVICE_NAME=$(aws --profile groschat ec2 create-vpc-endpoint-service-configuration   --network-load-balancer-arns <NLB_ARN>   --no-acceptance-required   --query 'ServiceConfiguration.ServiceName'   --output text)

# Récupérer l’identifiant court du service, par exemple vpce-svc-xxxx.
SERVICE_ID=$(aws --profile groschat ec2 describe-vpc-endpoint-service-configurations   --filters "Name=service-name,Values=$SERVICE_NAME"   --query 'ServiceConfigurations[0].ServiceId'   --output text)

# 6. Côté gros chat : autoriser le compte baleine à consommer ce service.
# Le suffixe :root signifie “le compte baleine”, pas l’utilisateur root.
aws --profile groschat ec2 modify-vpc-endpoint-service-permissions   --service-id "$SERVICE_ID"   --add-allowed-principals arn:aws:iam::<ACCOUNT_BALEINE>:root

# 7. Côté baleine : créer le Security Group de l’Interface Endpoint.
SG_BALEINE_VPCE=$(aws --profile baleine ec2 create-security-group   --group-name baleine-s3-gateway-vpce-sg   --description "PrivateLink endpoint to gros chat S3 gateway"   --vpc-id <VPC_BALEINE>   --query 'GroupId'   --output text)

# Autoriser les clients du VPC baleine à joindre l’endpoint sur le port 8080.
aws --profile baleine ec2 authorize-security-group-ingress   --group-id "$SG_BALEINE_VPCE"   --protocol tcp   --port 8080   --cidr <CIDR_VPC_BALEINE>

# 8. Côté baleine : créer l’Interface Endpoint consommateur.
VPCE_BALEINE=$(aws --profile baleine ec2 create-vpc-endpoint   --vpc-id <VPC_BALEINE>   --service-name "$SERVICE_NAME"   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_BALEINE_A> <SUBNET_BALEINE_B>   --security-group-ids "$SG_BALEINE_VPCE"   --no-private-dns-enabled   --tag-specifications 'ResourceType=vpc-endpoint,Tags=[{Key=Name,Value=baleine-to-groschat-s3-gateway}]'   --query 'VpcEndpoint.VpcEndpointId'   --output text)

# 9. Attendre que l’endpoint baleine soit disponible.
aws --profile baleine ec2 wait vpc-endpoint-available   --vpc-endpoint-ids "$VPCE_BALEINE"

# 10. Récupérer le DNS privé que l’application baleine utilisera comme endpoint S3 custom.
DNS_PRIVATELINK_BALEINE=$(aws --profile baleine ec2 describe-vpc-endpoints   --vpc-endpoint-ids "$VPCE_BALEINE"   --query 'VpcEndpoints[0].DnsEntries[0].DnsName'   --output text)

echo "$DNS_PRIVATELINK_BALEINE"

aws ec2 modify-vpc-endpoint-service-permissions \
  --service-id <VPCE_SERVICE_ID> \
  --add-allowed-principals arn:aws:iam::<ACCOUNT_BALEINE>:root

aws ec2 create-vpc-endpoint \
  --vpc-id <VPC_BALEINE> \
  --service-name com.amazonaws.vpce.eu-west-3.<VPCE_SERVICE_ID> \
  --vpc-endpoint-type Interface \
  --subnet-ids <SUBNET_A> <SUBNET_B> \
  --security-group-ids <SG_VPCE_BALEINE> \
  --no-private-dns-enabled

timeout 5 bash -c 'cat < /dev/null > /dev/tcp/<DNS_PRIVATELINK_BALEINE>/8080' \
  && echo OK || echo KO

AWS_ACCESS_KEY_ID=<LOCAL_ACCESS_KEY> \
AWS_SECRET_ACCESS_KEY=<LOCAL_SECRET_KEY> \
AWS_EC2_METADATA_DISABLED=true \
aws s3 ls s3://mab-documents \
  --endpoint-url http://<DNS_PRIVATELINK_BALEINE>:8080 \
  --region eu-west-3

2026-05-28 19:46:23         21 fifi.txt
2026-05-28 19:46:23         20 loulou.txt
2026-05-28 19:46:24         20 riri.txt

AWS_ACCESS_KEY_ID=<LOCAL_ACCESS_KEY> \
AWS_SECRET_ACCESS_KEY=<LOCAL_SECRET_KEY> \
AWS_EC2_METADATA_DISABLED=true \
aws s3 cp s3://mab-documents/fifi.txt - \
  --endpoint-url http://<DNS_PRIVATELINK_BALEINE>:8080 \
  --region eu-west-3

Fifi mange une figue

mkdir -p ~/mab-documents

AWS_ACCESS_KEY_ID=<LOCAL_ACCESS_KEY> \
AWS_SECRET_ACCESS_KEY=<LOCAL_SECRET_KEY> \
AWS_EC2_METADATA_DISABLED=true \
aws s3 cp s3://mab-documents ~/mab-documents \
  --recursive \
  --endpoint-url http://<DNS_PRIVATELINK_BALEINE>:8080 \
  --region eu-west-3

ls -l ~/mab-documents
cat ~/mab-documents/fifi.txt

# On crée un répertoire séparé pour ce POC.
# Objectif : ne pas modifier ~/.aws/config ni ~/.aws/credentials utilisés au quotidien.
mkdir -p ~/.aws-poc-s3-gateway

# Fichier de configuration isolé : deux profils, un par compte AWS.
# groschat = compte propriétaire du bucket et de la passerelle.
# baleine  = compte consommateur de la passerelle.
cat > ~/.aws-poc-s3-gateway/config <<'EOF'
[profile groschat]
region = eu-west-3
output = json

[profile baleine]
region = eu-west-3
output = json
EOF

# Fichier de credentials isolé.
# Les access keys dédiées au POC seront mises ici, pas dans le profil par défaut.
touch ~/.aws-poc-s3-gateway/credentials
chmod 600 ~/.aws-poc-s3-gateway/credentials

# Petit fichier à sourcer dans le terminal pour dire à AWS CLI d'utiliser ces fichiers isolés.
cat > ~/aws-poc-s3-gateway.env <<'EOF'
export AWS_CONFIG_FILE=$HOME/.aws-poc-s3-gateway/config
export AWS_SHARED_CREDENTIALS_FILE=$HOME/.aws-poc-s3-gateway/credentials
export AWS_PAGER=""
EOF

# Activation dans le terminal courant.
source ~/aws-poc-s3-gateway.env

# Trust policy : autorise ECS Tasks à assumer ce rôle.
# Sans cette relation de confiance, Fargate ne pourrait pas fournir ce rôle au conteneur.
cat > /tmp/trust-ecs-task.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": { "Service": "ecs-tasks.amazonaws.com" },
    "Action": "sts:AssumeRole"
  }]
}
EOF

# Task Role = rôle applicatif visible par le conteneur.
# C'est ce rôle que rclone utilise indirectement avec env_auth = true.
aws --profile groschat iam create-role   --role-name rclone-s3-gateway-task-role   --assume-role-policy-document file:///tmp/trust-ecs-task.json

# Policy minimale : rclone doit seulement lister le bucket et lire les objets.
# Il n'a pas besoin de PutObject, DeleteObject ou d'un accès à d'autres buckets.
cat > /tmp/rclone-read-mab-documents-policy.json <<'EOF'
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListBucket",
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::mab-documents"
    },
    {
      "Sid": "ReadObjects",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::mab-documents/*"
    }
  ]
}
EOF

aws --profile groschat iam put-role-policy   --role-name rclone-s3-gateway-task-role   --policy-name ReadOnlyMabDocuments   --policy-document file:///tmp/rclone-read-mab-documents-policy.json

# Execution Role = rôle technique d'ECS.
# Il sert à tirer l'image depuis ECR et à écrire les logs dans CloudWatch.
# Il ne doit pas être confondu avec le Task Role qui lit le bucket S3.
aws --profile groschat iam create-role   --role-name ecsTaskExecutionRole   --assume-role-policy-document file:///tmp/trust-ecs-task.json

aws --profile groschat iam attach-role-policy   --role-name ecsTaskExecutionRole   --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy

# Remote mabaws : accès au vrai S3 AWS côté gros chat.
# env_auth = true signifie : ne pas mettre de clés AWS dans le fichier.
# rclone récupère ses credentials via le Task Role Fargate.
[mabaws]
type = s3
provider = AWS
env_auth = true
region = eu-west-3
location_constraint = eu-west-3

# Remote gateway : racine artificielle exposée par rclone serve s3.
# La ligne ci-dessous crée un bucket logique mab-documents côté client.
# Ce bucket logique pointe vers le vrai bucket AWS mabaws:mab-documents.
[gateway]
type = combine
upstreams = mab-documents=mabaws:mab-documents

# Image officielle rclone.
FROM rclone/rclone:latest

# On embarque la configuration rclone dans l'image.
# Pour un POC c'est simple ; en production, on préférerait monter/injecter la config.
COPY rclone.conf /config/rclone/rclone.conf

# Le conteneur écoute en TCP sur 8080.
EXPOSE 8080

# ENTRYPOINT fixe le binaire lancé.
ENTRYPOINT ["rclone"]

# CMD lance un serveur S3-compatible.
# gateway: est le remote combine qui expose mab-documents comme bucket logique.
# --auth-key protège la passerelle avec une paire access_key/secret_key applicative.
# Ces credentials ne sont pas des credentials AWS.
CMD ["serve", "s3", "gateway:", "--addr", ":8080", "--auth-key", "<LOCAL_ACCESS_KEY>,<LOCAL_SECRET_KEY>", "--vfs-cache-mode", "off", "-vv"]

# La task Fargate est dans des subnets privés, sans NAT ni Internet Gateway.
# Elle a donc besoin d'endpoints privés pour contacter les services AWS nécessaires.

# Endpoint Gateway S3 : permet à rclone d'accéder au bucket S3 sans sortir sur Internet.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.s3   --vpc-endpoint-type Gateway   --route-table-ids <ROUTE_TABLE_GROSCHAT>

# Endpoint Interface ECR API : permet à ECS/Fargate de parler à l'API ECR.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.ecr.api   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_GROSCHAT_A> <SUBNET_GROSCHAT_B>   --security-group-ids <SG_ENDPOINTS_AWS>   --private-dns-enabled

# Endpoint Interface ECR DKR : permet de tirer les layers Docker de l'image.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.ecr.dkr   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_GROSCHAT_A> <SUBNET_GROSCHAT_B>   --security-group-ids <SG_ENDPOINTS_AWS>   --private-dns-enabled

# Endpoint Interface CloudWatch Logs : permet au conteneur d'envoyer ses logs.
aws --profile groschat ec2 create-vpc-endpoint   --vpc-id <VPC_GROSCHAT>   --service-name com.amazonaws.eu-west-3.logs   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_GROSCHAT_A> <SUBNET_GROSCHAT_B>   --security-group-ids <SG_ENDPOINTS_AWS>   --private-dns-enabled

# create-service demande à ECS de maintenir une task active.
# --desired-count 1 : on veut exactement une passerelle en fonctionnement.
# --launch-type FARGATE : pas d'EC2 à gérer.
# networkConfiguration : la task reçoit une ENI privée dans les subnets indiqués.
# assignPublicIp=DISABLED : pas d'IP publique sur la task.
aws --profile groschat ecs create-service   --cluster rclone-s3-gateway-cluster   --service-name rclone-s3-gateway-service   --task-definition "$TASK_DEF_ARN"   --desired-count 1   --launch-type FARGATE   --network-configuration "awsvpcConfiguration={subnets=[<SUBNET_GROSCHAT_A>,<SUBNET_GROSCHAT_B>],securityGroups=[<SG_ECS_TASK>],assignPublicIp=DISABLED}"

# Après ajout du NLB, on rattache le Target Group au service.
# ECS enregistrera automatiquement l'IP privée de la task dans le Target Group.
aws --profile groschat ecs update-service   --cluster rclone-s3-gateway-cluster   --service rclone-s3-gateway-service   --load-balancers targetGroupArn=<TG_ARN>,containerName=rclone-s3-gateway,containerPort=8080   --force-new-deployment

# gros chat expose son NLB comme Endpoint Service PrivateLink.
# --no-acceptance-required simplifie le POC : la connexion n'a pas besoin d'être acceptée manuellement.
aws --profile groschat ec2 create-vpc-endpoint-service-configuration   --network-load-balancer-arns <NLB_ARN>   --no-acceptance-required

# gros chat autorise le compte baleine à créer un Interface Endpoint vers ce service.
# :root signifie ici "le compte AWS baleine", pas l'utilisateur root utilisé en console.
aws --profile groschat ec2 modify-vpc-endpoint-service-permissions   --service-id <VPCE_SERVICE_ID>   --add-allowed-principals arn:aws:iam::<ACCOUNT_BALEINE>:root

# baleine crée un Interface Endpoint dans son VPC.
# Le DNS retourné par AWS sera privé au VPC baleine.
# --no-private-dns-enabled : on ne remplace pas le DNS AWS S3 global ; on utilise un endpoint explicite.
aws --profile baleine ec2 create-vpc-endpoint   --vpc-id <VPC_BALEINE>   --service-name com.amazonaws.vpce.eu-west-3.<VPCE_SERVICE_ID>   --vpc-endpoint-type Interface   --subnet-ids <SUBNET_BALEINE_A> <SUBNET_BALEINE_B>   --security-group-ids <SG_VPCE_BALEINE>   --no-private-dns-enabled

# Le DNS PrivateLink est privé au VPC baleine.
# Depuis ton PC local, il peut ne pas se résoudre ou ne pas être joignable.
# On lance donc les commandes depuis une EC2 temporaire dans le VPC baleine,
# pilotée par Systems Manager Session Manager, sans clé SSH.

# Test DNS : doit retourner une IP privée 172.31.x.x côté baleine.
getent hosts <DNS_PRIVATELINK_BALEINE>

# Test TCP : vérifie que le port 8080 répond jusqu'à rclone.
timeout 5 bash -c 'cat < /dev/null > /dev/tcp/<DNS_PRIVATELINK_BALEINE>/8080'   && echo OK || echo KO

# Test HTTP brut : une erreur XML S3 est acceptable ici.
# Elle prouve que le service répond, même si curl ne signe pas correctement la requête S3.
curl -i --max-time 10 http://<DNS_PRIVATELINK_BALEINE>:8080/ | head -40

# Credentials applicatifs transmis à baleine.
# Ce ne sont pas des clés AWS et elles ne donnent aucun droit IAM sur gros chat.
export AWS_ACCESS_KEY_ID=<LOCAL_ACCESS_KEY>
export AWS_SECRET_ACCESS_KEY=<LOCAL_SECRET_KEY>
export AWS_EC2_METADATA_DISABLED=true

# Listing du bucket logique exposé par la passerelle.
aws s3 ls s3://mab-documents   --endpoint-url http://<DNS_PRIVATELINK_BALEINE>:8080   --region eu-west-3

# Lecture d'un objet : le contenu vient du vrai bucket S3 dans gros chat.
aws s3 cp s3://mab-documents/fifi.txt -   --endpoint-url http://<DNS_PRIVATELINK_BALEINE>:8080   --region eu-west-3

# Copie des fichiers sur le disque local de l'instance cliente baleine.
mkdir -p ~/mab-documents
aws s3 cp s3://mab-documents ~/mab-documents   --recursive   --endpoint-url http://<DNS_PRIVATELINK_BALEINE>:8080   --region eu-west-3

run_baleine() {
  local COMMENT="$1"
  local COMMAND="$2"

  COMMAND_ID=$(aws --profile baleine ssm send-command \
    --instance-ids "$INSTANCE_TEST_BALEINE" \
    --document-name "AWS-RunShellScript" \
    --comment "$COMMENT" \
    --parameters "commands=[\"$COMMAND\"]" \
    --query 'Command.CommandId' \
    --output text)

  aws --profile baleine ssm wait command-executed \
    --command-id "$COMMAND_ID" \
    --instance-id "$INSTANCE_TEST_BALEINE"

  aws --profile baleine ssm get-command-invocation \
    --command-id "$COMMAND_ID" \
    --instance-id "$INSTANCE_TEST_BALEINE" \
    --query '{Status:Status,Output:StandardOutputContent,Error:StandardErrorContent}' \
    --output json
}

source ~/aws-poc-s3-gateway.env
source ~/poc-s3-gateway/poc-vars.env
export AWS_PAGER=""

# Couper immédiatement la passerelle : plus aucune task Fargate ne tourne.
aws --profile groschat ecs update-service \
  --cluster rclone-s3-gateway-cluster \
  --service rclone-s3-gateway-service \
  --desired-count 0

aws --profile groschat ecs wait services-stable \
  --cluster rclone-s3-gateway-cluster \
  --services rclone-s3-gateway-service

aws --profile groschat ecs describe-services \
  --cluster rclone-s3-gateway-cluster \
  --services rclone-s3-gateway-service \
  --query 'services[0].{Desired:desiredCount,Running:runningCount,Pending:pendingCount}' \
  --output table

aws --profile groschat ecs update-service \
  --cluster rclone-s3-gateway-cluster \
  --service rclone-s3-gateway-service \
  --desired-count 1

aws --profile groschat ecs wait services-stable \
  --cluster rclone-s3-gateway-cluster \
  --services rclone-s3-gateway-service

# Empêche le compte baleine de créer de nouveaux endpoints vers le service.
aws --profile groschat ec2 modify-vpc-endpoint-service-permissions \
  --service-id "$VPCE_SERVICE_ID" \
  --remove-allowed-principals "arn:aws:iam::$BALEINE_ACCOUNT_ID:root"

aws --profile groschat ec2 describe-vpc-endpoint-service-permissions \
  --service-id "$VPCE_SERVICE_ID" \
  --query 'AllowedPrincipals[*].Principal' \
  --output text

# À utiliser si l'endpoint consommateur baleine existe encore.
aws --profile groschat ec2 reject-vpc-endpoint-connections \
  --service-id "$VPCE_SERVICE_ID" \
  --vpc-endpoint-ids "$VPCE_BALEINE"

aws --profile groschat ec2 describe-vpc-endpoint-connections \
  --filters "Name=service-id,Values=$VPCE_SERVICE_ID" \
  --query 'VpcEndpointConnections[*].{Endpoint:VpcEndpointId,State:VpcEndpointState,Owner:VpcEndpointOwner}' \
  --output table

source ~/aws-poc-s3-gateway.env
source ~/poc-s3-gateway/poc-vars.env
export AWS_PAGER=""

# Pour éviter les surprises, on vérifie les variables critiques.
echo "TG_ARN=$TG_ARN"
echo "TASK_DEF_ARN=$TASK_DEF_ARN"
echo "VPCE_BALEINE=$VPCE_BALEINE"
echo "VPC_GROSCHAT=$VPC_GROSCHAT"
echo "SG_VPCE_BALEINE=$SG_VPCE_BALEINE"

aws --profile groschat ecs update-service \
  --cluster rclone-s3-gateway-cluster \
  --service rclone-s3-gateway-service \
  --desired-count 0 || echo "Service ECS déjà absent ou déjà arrêté"

aws --profile groschat ecs wait services-stable \
  --cluster rclone-s3-gateway-cluster \
  --services rclone-s3-gateway-service || echo "Service ECS déjà absent"

aws --profile groschat ecs delete-service \
  --cluster rclone-s3-gateway-cluster \
  --service rclone-s3-gateway-service \
  --force || echo "Service ECS déjà supprimé"

aws --profile groschat ecs wait services-inactive \
  --cluster rclone-s3-gateway-cluster \
  --services rclone-s3-gateway-service || echo "Service ECS déjà inactif"

aws --profile groschat ecs delete-cluster \
  --cluster rclone-s3-gateway-cluster || echo "Cluster ECS déjà supprimé"

# Supprime l'Endpoint Service PrivateLink exposé à baleine.
aws --profile groschat ec2 delete-vpc-endpoint-service-configurations \
  --service-ids "$VPCE_SERVICE_ID" || echo "Endpoint Service déjà supprimé"

# Supprime le listener TCP 8080.
aws --profile groschat elbv2 delete-listener \
  --listener-arn "$LISTENER_ARN" || echo "Listener déjà supprimé"

# Supprime le NLB interne.
aws --profile groschat elbv2 delete-load-balancer \
  --load-balancer-arn "$NLB_ARN" || echo "NLB déjà supprimé"

aws --profile groschat elbv2 wait load-balancers-deleted \
  --load-balancer-arns "$NLB_ARN" || echo "NLB déjà absent"

# Supprime le Target Group.
# Attention : la bonne variable est TG_ARN, pas TARGET_GROUP_ARN.
aws --profile groschat elbv2 delete-target-group \
  --target-group-arn "$TG_ARN" || echo "Target Group déjà supprimé"

aws --profile groschat ec2 delete-vpc-endpoints \
  --vpc-endpoint-ids \
    "$VPCE_S3" \
    "$VPCE_ECR_API" \
    "$VPCE_ECR_DKR" \
    "$VPCE_LOGS" || echo "Endpoints gros chat déjà supprimés"

# Les ENI des Interface Endpoints peuvent rester quelques minutes.
# On attend qu'il ne reste plus aucune ENI dans le VPC du POC avant de supprimer SG/VPC.
while aws --profile groschat ec2 describe-network-interfaces \
  --filters "Name=vpc-id,Values=$VPC_GROSCHAT" \
  --query 'NetworkInterfaces[*].NetworkInterfaceId' \
  --output text | grep -q .; do
  echo "ENI encore présentes côté gros chat, attente 15 secondes..."
  aws --profile groschat ec2 describe-network-interfaces \
    --filters "Name=vpc-id,Values=$VPC_GROSCHAT" \
    --query 'NetworkInterfaces[*].{Eni:NetworkInterfaceId,Status:Status,Description:Description}' \
    --output table
  sleep 15
done

# Termine l'EC2 temporaire utilisée pour tester depuis le VPC baleine.
aws --profile baleine ec2 terminate-instances \
  --instance-ids "$INSTANCE_TEST_BALEINE" || echo "Instance de test déjà absente"

aws --profile baleine ec2 wait instance-terminated \
  --instance-ids "$INSTANCE_TEST_BALEINE" || echo "Instance de test déjà terminée"

# Supprime l'Interface Endpoint consommateur côté baleine.
# Attention : la bonne variable est VPCE_BALEINE, pas BALEINE_VPCE_ID.
aws --profile baleine ec2 delete-vpc-endpoints \
  --vpc-endpoint-ids "$VPCE_BALEINE" || echo "Endpoint baleine déjà supprimé"

# Attend que l'endpoint ne soit plus visible.
while aws --profile baleine ec2 describe-vpc-endpoints \
  --vpc-endpoint-ids "$VPCE_BALEINE" >/dev/null 2>&1; do
  echo "Endpoint baleine encore visible, attente 15 secondes..."
  sleep 15
done

# Attend que les ENI associées au SG de l'endpoint disparaissent.
while aws --profile baleine ec2 describe-network-interfaces \
  --filters "Name=group-id,Values=$SG_VPCE_BALEINE" \
  --query 'NetworkInterfaces[*].NetworkInterfaceId' \
  --output text | grep -q .; do
  echo "ENI encore présentes côté baleine, attente 15 secondes..."
  aws --profile baleine ec2 describe-network-interfaces \
    --filters "Name=group-id,Values=$SG_VPCE_BALEINE" \
    --query 'NetworkInterfaces[*].{Eni:NetworkInterfaceId,Status:Status,Description:Description}' \
    --output table
  sleep 15
done

# Supprime les Security Groups du POC côté baleine.
aws --profile baleine ec2 delete-security-group \
  --group-id "$SG_TEST_EC2_BALEINE" || echo "SG EC2 baleine déjà supprimé"

aws --profile baleine ec2 delete-security-group \
  --group-id "$SG_VPCE_BALEINE" || echo "SG endpoint baleine déjà supprimé"

# Supprime d'abord les Security Groups quand les ENI ont disparu.
aws --profile groschat ec2 delete-security-group \
  --group-id "$SG_VPCE_GROSCHAT" || echo "SG VPCE gros chat déjà supprimé"

aws --profile groschat ec2 delete-security-group \
  --group-id "$SG_ECS" || echo "SG ECS déjà supprimé"

# Désassocie les subnets de la route table dédiée.
aws --profile groschat ec2 disassociate-route-table \
  --association-id "$RTB_ASSOC_A" || echo "Association route table A déjà absente"

aws --profile groschat ec2 disassociate-route-table \
  --association-id "$RTB_ASSOC_B" || echo "Association route table B déjà absente"

# Supprime route table, subnets puis VPC du POC.
aws --profile groschat ec2 delete-route-table \
  --route-table-id "$RTB_GROSCHAT" || echo "Route table déjà supprimée"

aws --profile groschat ec2 delete-subnet \
  --subnet-id "$SUBNET_GROSCHAT_A" || echo "Subnet A déjà supprimé"

aws --profile groschat ec2 delete-subnet \
  --subnet-id "$SUBNET_GROSCHAT_B" || echo "Subnet B déjà supprimé"

aws --profile groschat ec2 delete-vpc \
  --vpc-id "$VPC_GROSCHAT" || echo "VPC gros chat déjà supprimé"

# Supprime les logs du conteneur rclone.
aws --profile groschat logs delete-log-group \
  --log-group-name /ecs/rclone-s3-gateway || echo "Log group déjà supprimé"

# Supprime l'image Docker et le repository ECR du POC.
aws --profile groschat ecr delete-repository \
  --repository-name rclone-s3-gateway \
  --force || echo "Repository ECR déjà supprimé"

# Les task definitions ne coûtent pas, mais on peut désenregistrer les révisions actives.
for TD in $(aws --profile groschat ecs list-task-definitions \
  --family-prefix rclone-s3-gateway \
  --status ACTIVE \
  --query 'taskDefinitionArns[]' \
  --output text); do
  aws --profile groschat ecs deregister-task-definition \
    --task-definition "$TD"
done

# Côté gros chat : rôle applicatif Fargate.
aws --profile groschat iam delete-role-policy \
  --role-name rclone-s3-gateway-task-role \
  --policy-name ReadOnlyMabDocuments || echo "Policy inline déjà supprimée"

aws --profile groschat iam delete-role \
  --role-name rclone-s3-gateway-task-role || echo "Task Role déjà supprimé"

# Côté gros chat : execution role ECS.
aws --profile groschat iam detach-role-policy \
  --role-name ecsTaskExecutionRole \
  --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy || echo "Policy execution role déjà détachée"

aws --profile groschat iam delete-role \
  --role-name ecsTaskExecutionRole || echo "Execution role déjà supprimé"

# Côté baleine : rôle EC2 SSM utilisé par l'instance temporaire.
aws --profile baleine iam remove-role-from-instance-profile \
  --instance-profile-name poc-s3-gateway-ec2-ssm-profile \
  --role-name poc-s3-gateway-ec2-ssm-role || echo "Rôle déjà retiré de l'instance profile"

aws --profile baleine iam delete-instance-profile \
  --instance-profile-name poc-s3-gateway-ec2-ssm-profile || echo "Instance profile déjà supprimé"

aws --profile baleine iam detach-role-policy \
  --role-name poc-s3-gateway-ec2-ssm-role \
  --policy-arn arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore || echo "Policy SSM déjà détachée"

aws --profile baleine iam delete-role \
  --role-name poc-s3-gateway-ec2-ssm-role || echo "Rôle SSM baleine déjà supprimé"

# À lancer depuis un autre accès admin que les users à supprimer.

# gros chat
for KEY in $(aws --profile groschat iam list-access-keys \
  --user-name poc-s3-gateway-admin \
  --query 'AccessKeyMetadata[*].AccessKeyId' \
  --output text); do
  aws --profile groschat iam delete-access-key \
    --user-name poc-s3-gateway-admin \
    --access-key-id "$KEY"
done

aws --profile groschat iam detach-user-policy \
  --user-name poc-s3-gateway-admin \
  --policy-arn arn:aws:iam::aws:policy/AdministratorAccess || echo "Policy admin gros chat déjà détachée"

aws --profile groschat iam delete-user \
  --user-name poc-s3-gateway-admin || echo "User admin gros chat déjà supprimé"

# baleine
for KEY in $(aws --profile baleine iam list-access-keys \
  --user-name poc-s3-gateway-client-admin \
  --query 'AccessKeyMetadata[*].AccessKeyId' \
  --output text); do
  aws --profile baleine iam delete-access-key \
    --user-name poc-s3-gateway-client-admin \
    --access-key-id "$KEY"
done

aws --profile baleine iam detach-user-policy \
  --user-name poc-s3-gateway-client-admin \
  --policy-arn arn:aws:iam::aws:policy/AdministratorAccess || echo "Policy admin baleine déjà détachée"

aws --profile baleine iam delete-user \
  --user-name poc-s3-gateway-client-admin || echo "User admin baleine déjà supprimé"

echo "=============================="
echo "GROS CHAT — ressources coûteuses ou structurantes"
echo "=============================="

aws --profile groschat ecs list-clusters \
  --query 'clusterArns[]' \
  --output table

aws --profile groschat elbv2 describe-load-balancers \
  --query 'LoadBalancers[*].{Name:LoadBalancerName,VpcId:VpcId,State:State.Code}' \
  --output table

# Contrôle ajouté : les Target Groups orphelins ne sortent pas dans describe-load-balancers.
aws --profile groschat elbv2 describe-target-groups \
  --query 'TargetGroups[?contains(TargetGroupName,`rclone`)].{Name:TargetGroupName,Arn:TargetGroupArn,VpcId:VpcId}' \
  --output table

aws --profile groschat ec2 describe-vpc-endpoint-service-configurations \
  --query 'ServiceConfigurations[*].{ServiceId:ServiceId,State:ServiceState,ServiceName:ServiceName}' \
  --output table

aws --profile groschat ec2 describe-vpc-endpoints \
  --query 'VpcEndpoints[*].{Id:VpcEndpointId,State:State,Service:ServiceName,VpcId:VpcId}' \
  --output table

aws --profile groschat ec2 describe-network-interfaces \
  --query 'NetworkInterfaces[*].{Eni:NetworkInterfaceId,Status:Status,Description:Description,VpcId:VpcId}' \
  --output table

aws --profile groschat ec2 describe-nat-gateways \
  --query 'NatGateways[*].{Id:NatGatewayId,State:State,VpcId:VpcId}' \
  --output table

aws --profile groschat ec2 describe-instances \
  --query 'Reservations[*].Instances[*].{InstanceId:InstanceId,State:State.Name,Name:Tags[?Key==`Name`].Value|[0]}' \
  --output table

aws --profile groschat ec2 describe-addresses \
  --query 'Addresses[*].{PublicIp:PublicIp,AllocationId:AllocationId,AssociationId:AssociationId}' \
  --output table

aws --profile groschat ecr describe-repositories \
  --query 'repositories[*].repositoryName' \
  --output table || echo "Aucun repository ECR du POC"

aws --profile groschat logs describe-log-groups \
  --log-group-name-prefix /ecs/rclone-s3-gateway \
  --query 'logGroups[*].logGroupName' \
  --output table

echo "=============================="
echo "BALEINE — endpoint, EC2 et réseau de test"
echo "=============================="

# C'est le contrôle le plus important côté coût.
aws --profile baleine ec2 describe-vpc-endpoints \
  --query 'VpcEndpoints[*].{Id:VpcEndpointId,State:State,Service:ServiceName,VpcId:VpcId}' \
  --output table

aws --profile baleine ec2 describe-instances \
  --query 'Reservations[*].Instances[*].{InstanceId:InstanceId,State:State.Name,Name:Tags[?Key==`Name`].Value|[0]}' \
  --output table

aws --profile baleine elbv2 describe-load-balancers \
  --query 'LoadBalancers[*].{Name:LoadBalancerName,VpcId:VpcId,State:State.Code}' \
  --output table

aws --profile baleine ec2 describe-network-interfaces \
  --query 'NetworkInterfaces[*].{Eni:NetworkInterfaceId,Status:Status,Description:Description,VpcId:VpcId}' \
  --output table

aws --profile baleine ec2 describe-nat-gateways \
  --query 'NatGateways[*].{Id:NatGatewayId,State:State,VpcId:VpcId}' \
  --output table

aws --profile baleine ec2 describe-addresses \
  --query 'Addresses[*].{PublicIp:PublicIp,AllocationId:AllocationId,AssociationId:AssociationId}' \
  --output table

echo "=============================="
echo "IAM temporaires — sécurité"
echo "=============================="

aws --profile groschat iam list-access-keys \
  --user-name poc-s3-gateway-admin \
  --query 'AccessKeyMetadata[*].{User:UserName,AccessKeyId:AccessKeyId,Status:Status}' \
  --output table || echo "User admin gros chat absent"

aws --profile baleine iam list-access-keys \
  --user-name poc-s3-gateway-client-admin \
  --query 'AccessKeyMetadata[*].{User:UserName,AccessKeyId:AccessKeyId,Status:Status}' \
  --output table || echo "User admin baleine absent"