Hextra theme (#1)

* Adapt theme
* Update Contents to match with new theme
* chore: few updates
* adapt HomePage
* Add icons and french version
* fix fr homepage
* Fix Netlab view
* Fix Netlab articles
* devpod post
* French version of DevPod
* my_first_lab

content/documentation/devpod/_index.fr.md

@@ -0,0 +1,317 @@
+---
+title: "DevPod sur AWS"
+date: 2025-02-11T20:00:00+02:00
+weight: 1
+cascade:
+  type: docs
+---
+
+## Sources
+
+- [DevPod](https://devpod.sh/docs/what-is-devpod) ⚙️
+- [DevContainer](https://containers.dev) 🐳
+
+## Introduction 🚀
+
+Dans cet article, je souhaite présenter un outil fantastique qui fait partie de la même famille que GitPod et Codespaces : **DevPod** ! Il vous permet de créer des environnements de développement sans effort — sans se retrouver bloqué par un fournisseur. 🔒❌
+
+DevPod est basé sur l'architecture **DevContainer** et utilise les spécifications contenues dans un fichier [devcontainer.json](https://containers.dev) pour lancer votre environnement de développement. Personnellement, je l'utilise pour déployer rapidement des maquette réseau avec ContainerLab. 💻🧰
+
+## Qu'est-ce qu'un DevContainer ? 🤔
+
+Un conteneur de développement (souvent appelé « dev container ») vous permet d'utiliser un conteneur comme un environnement de développement complet. (Consultez la documentation officielle de [containers.dev](https://containers.dev) pour plus de détails.)
+
+Décomposons cela :
+
+Avez-vous déjà entendu l'expression « Ça marche sur ma machine » ? Si vous êtes développeur, vous avez sans doute rencontré ce problème en collaborant avec d'autres. Mais devinez quoi ? Les **DevContainers** résolvent le problème de la dérive des environnements en fournissant des environnements Docker cohérents et reproductibles. Adieu les maux de tête liés à l'installation ! 💆‍♀️
+
+Avec les DevContainers, il vous suffit de :
+
+1. Un dossier `.devcontainer` dans votre projet.
+2. Un fichier `devcontainer.json` qui indique à VS Code comment configurer le conteneur.
+3. Docker installé localement
+
+La pierre angulaire du DevContainer est le fichier `devcontainer.json`. Par exemple :
+
+```json
+{
+  "name": "Python DevContainer",
+  "image": "mcr.microsoft.com/devcontainers/python:3.10",
+  "features": {
+    "docker-in-docker": "latest"
+  },
+  "extensions": [
+    "ms-python.python",
+    "ms-azuretools.vscode-docker"
+  ]
+}
+```
+
+**Que se passe-t-il ici ?** 🕵️‍♀️
+
+- **"image"** – Cela utilise un environnement Python 3.10 prêt à l'emploi.
+- **"features"** – Cela ajoute la prise en charge de Docker dans le conteneur.
+- **"extensions"** – Installe des extensions utiles pour Python et Docker dans VS Code.
+
+Les DevContainers sont formidables pour le développement local, mais parfois vous avez besoin de plus de puissance — peut-être que vos charges de travail sont énormes, ou que vous souhaitez exécuter des laboratoires spécialisés. C'est là qu'intervient **DevPod**. 💪  
+**Pour pouvoir déployer facilement des laboratoires sur le Cloud**
+
+## Qu'est-ce que DevPod ? 🤖
+
+**DevPod** est un outil open-source qui vous permet de lancer des environnements de développement soit sur votre machine locale, soit dans le cloud de votre choix. Imaginez une version auto-hébergée et ultra-personnalisable de GitHub Codespaces. 🎉
+
+Dans mes aventures quotidiennes en réseau, je déploie des configurations basées sur ContainerLab avec des DevContainers sur AWS. Voyons comment vous pouvez utiliser DevPod pour faire exactement cela (les détails sur ContainerLab suivront dans un autre article, promis !). 😜
+
+## Fournisseur AWS 🌐
+
+DevPod utilise des **Providers** (fournisseurs), qui sont des modules de configuration définissant où et comment DevPod lance votre environnement. Voici la liste des fournisseurs :
+
+![Provider_list](provider.png#center)
+
+Nous allons nous concentrer sur le **Provider AWS** — bien qu'il existe de nombreuses options de configuration :
+
+![Provider_list](aws_options.png#center)
+
+Avant de paniquer devant tous ces réglages, ne vous inquiétez pas. Si vous ne faites que quelques expérimentations, les valeurs par défaut conviennent généralement. 🙌
+
+> [!NOTE] **Les avantages de l'open-source** 🎁
+>
+> Le fait que DevPod soit open-source signifie que vous pouvez jeter un œil sous le capot pour voir exactement comment il fonctionne. Consultez le code AWS [ici](https://github.com/loft-sh/devpod-provider-aws/tree/main) si vous êtes curieux.
+
+## Fonctionnement du code AWS
+
+Examinons ce que fait DevPod sur AWS en regardant le [code aws.go](https://github.com/loft-sh/devpod-provider-aws/blob/main/pkg/aws/aws.go). À un niveau global, il gère :
+
+1. **Initialisation** : Lecture de la configuration et mise en place des clients du SDK AWS (avec des identifiants personnalisés si nécessaire).
+2. **Réseautage** : Recherche ou création du sous-réseau, VPC et groupes de sécurité appropriés.
+3. **Sélection de l'AMI** : Choix d'une AMI adaptée (par défaut, une image Ubuntu 22.04 récente) et détermination du périphérique racine.
+4. **Configuration IAM** : Vérification qu'un rôle d'instance approprié et un profil d'instance existent, avec les politiques associées.
+5. **Cycle de vie de l'instance** : Création, démarrage, arrêt, vérification du statut et suppression des instances.
+6. **Injection de données utilisateur** : Génération d'un script (encodé en Base64) qui configure l'instance (ajoute des utilisateurs et des clés SSH) au premier démarrage.
+7. **DNS optionnel** : Gestion des enregistrements Route 53 pour l'instance si la configuration l'exige.
+
+De mon point de vue, deux points se distinguent comme étant potentiellement les plus critiques :
+
+- **(#4) Configuration IAM**
+- **(#6) Injection de données utilisateur**
+
+### Pourquoi les points #4 et #6 sont-ils « délicats » ?
+
+- **Configuration IAM** est principalement gérée par la fonction `CreateDevpodInstanceProfile`. Elle crée un rôle nommé `devpod-ec2-role` qui peut effectuer les opérations suivantes :
+  - **Opérations EC2** : Par exemple, il peut décrire ou arrêter des instances — en particulier l'instance qui lui est associée.
+  - **Opérations SSM** : En attachant la politique AmazonSSMManagedInstanceCore, l'instance peut être gérée par AWS Systems Manager.
+  - **Opérations KMS (optionnel)** : Si configuré, il peut exécuter `kms:Decrypt` sur une clé KMS spécifique, ce qui est utile pour gérer les données de session ou les secrets.
+
+- **Injection de données utilisateur** est essentiellement un script de démarrage inséré dans l'instance sous forme de Base64. Ce script configure un utilisateur `devpod` avec des droits sudo, crée les dossiers SSH et insère votre clé publique dans le fichier approprié. Dans le code, [cela ressemble à](https://github.com/loft-sh/devpod-provider-aws/blob/9d2730c34ecee40cb42596c602381b92ad9c6682/pkg/aws/aws.go#L967-L980) :
+
+  ```bash
+  useradd devpod -d /home/devpod
+  mkdir -p /home/devpod
+  if grep -q sudo /etc/groups; then
+    usermod -aG sudo devpod
+  elif grep -q wheel /etc/groups; then
+    usermod -aG wheel devpod
+  fi
+
+  echo "devpod ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/91-devpod
+  mkdir -p /home/devpod/.ssh
+  echo " + string(publicKey) + " >> /home/devpod/.ssh/authorized_keys
+  chmod 0700 /home/devpod/.ssh
+  chmod 0600 /home/devpod/.ssh/authorized_keys
+  chown -R devpod:devpod /home/devpod
+  ```
+
+Comme DevPod est open-source, vous pouvez facilement vérifier par vous-même. C'est un excellent outil d'apprentissage si vous souhaitez comprendre tous les rouages ! 🔩
+
+## Rôles et politiques IAM
+
+Vous devrez créer un utilisateur IAM et lui attacher une politique IAM qui accorde juste assez de permissions pour DevPod. Par exemple :
+
+- **Actions EC2 :**
+  - Description : `ec2:DescribeSubnets`, `ec2:DescribeVpcs`, `ec2:DescribeImages`, `ec2:DescribeInstances`, `ec2:DescribeSecurityGroups`
+  - Gestion des instances : `ec2:RunInstances`, `ec2:StartInstances`, `ec2:StopInstances`, `ec2:TerminateInstances`, `ec2:CancelSpotInstanceRequests`
+  - Groupes de sécurité & Tags : `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTags`
+- **Actions IAM :**
+  - `iam:GetInstanceProfile`, `iam:CreateRole`, `iam:PutRolePolicy`, `iam:AttachRolePolicy`, `iam:CreateInstanceProfile`, `iam:AddRoleToInstanceProfile`
+- **Route 53 (optionnel) :**
+  - `route53:ListHostedZones`, `route53:GetHostedZone`, `route53:ChangeResourceRecordSets`
+
+## Configuration AWS 🏗️
+
+J'utilise généralement la console web AWS pour configurer cela, mais vous pouvez tout à fait le faire via la CLI.
+
+### Étape 1 : Connectez-vous à la console AWS
+
+1. Rendez-vous sur [AWS Management Console](https://aws.amazon.com/console/).
+2. Utilisez un compte disposant des droits appropriés pour créer des ressources IAM.
+
+### Étape 2 : Créer une politique IAM personnalisée
+
+#### **A. Accédez à la console IAM**
+
+- Dans le menu AWS, trouvez **IAM**.
+
+#### **B. Créer une nouvelle politique**
+
+1. Cliquez sur **Policies** dans le menu de gauche.
+2. Cliquez sur **Create policy**.
+
+#### **C. Passez à l'onglet JSON**
+
+- Collez quelque chose comme ceci, en ajustant si nécessaire :
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "EC2Actions",
+      "Effect": "Allow",
+      "Action": [
+        "ec2:DescribeSubnets",
+        "ec2:DescribeVpcs",
+        "ec2:DescribeImages",
+        "ec2:DescribeInstances",
+        "ec2:DescribeSecurityGroups",
+        "ec2:RunInstances",
+        "ec2:StartInstances",
+        "ec2:StopInstances",
+        "ec2:TerminateInstances",
+        "ec2:CancelSpotInstanceRequests",
+        "ec2:CreateSecurityGroup",
+        "ec2:AuthorizeSecurityGroupIngress",
+        "ec2:CreateTags",
+        "ec2:DeleteTags"
+      ],
+      "Resource": "*"
+    },
+    {
+      "Sid": "IAMActions",
+      "Effect": "Allow",
+      "Action": [
+        "iam:GetInstanceProfile",
+        "iam:CreateRole",
+        "iam:PutRolePolicy",
+        "iam:AttachRolePolicy",
+        "iam:CreateInstanceProfile",
+        "iam:AddRoleToInstanceProfile"
+      ],
+      "Resource": "*"
+    },
+    {
+      "Sid": "Route53Actions",
+      "Effect": "Allow",
+      "Action": [
+        "route53:ListHostedZones",
+        "route53:GetHostedZone",
+        "route53:ChangeResourceRecordSets"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+```
+
+- Cliquez sur **Next** (les tags sont optionnels), puis sur **Next: Review**.
+
+#### **D. Vérifier et créer**
+
+1. Nommez-la `DevpodToolPolicy` (ou comme vous le souhaitez).
+2. Ajoutez une description facultative.
+3. Cliquez sur **Create policy**.
+
+### Étape 3 : Créer ou mettre à jour l'utilisateur IAM
+
+#### **A. Créer un nouvel utilisateur (si nécessaire)**
+
+1. Cliquez sur **Users** dans IAM.
+2. Cliquez sur **Add user**.
+3. Donnez-lui un nom (par exemple, `devpod-tool-user`).
+4. Choisissez **Programmatic access** si vous souhaitez un accès via la CLI. 🤖
+5. Cliquez sur **Next**.
+
+#### **B. Attacher votre nouvelle politique**
+
+1. Sur la page des permissions, choisissez **Attach policies directly**.
+2. Cochez `DevpodToolPolicy`.
+3. Cliquez sur **Create**.
+4. Et voilà !
+
+### Étape 4 : Vérifier et c'est fini
+
+Retournez dans **Users** → **devpod-tool-user** → **Permissions** pour confirmer que `DevpodToolPolicy` est bien attachée. ✅
+
+### Étape 5 : Utilisez ces identifiants
+
+- Si vous avez créé un utilisateur programmatique, n'oubliez pas de noter l'**Access Key ID** et le **Secret Access Key**.
+
+![devpod_user_sumup](devpod_user.png#center)
+
+**Bonus** : Notez votre **ID VPC** (dans la section VPC sur AWS). Vous en aurez besoin lors de la configuration de DevPod.
+
+## Configurer DevPod 🛠️
+
+### 1. Configurer le profil AWS
+
+```bash
+aws configure --profile Devpod
+```
+
+Lorsqu'on vous le demande :
+
+1. L'Access Key ID
+2. Le Secret Access Key
+3. La région par défaut (par exemple, `eu-west-1`)
+4. Le format de sortie (je le laisse généralement vide)
+
+### 2. Ajouter le profil à DevPod
+
+1. Dans DevPod, créez un nouveau provider et choisissez **AWS**.
+2. Sélectionnez la **région AWS** (par exemple, `eu-west-1`).
+3. Développez les options AWS.
+4. **Taille du disque AWS** : par exemple, 40 GB pour commencer.
+5. **Type d'instance** : par exemple, `t2.small`.
+6. **Profil AWS** : sélectionnez `Devpod` (ou le nom que vous avez choisi).
+7. **ID VPC AWS** : ajoutez votre VPC.
+8. Vous pouvez laisser le reste par défaut.
+
+Cliquez sur **Add Provider**.
+
+![added_new_provider](new_provider.png#center)
+
+## Tester un déploiement 🧪
+
+### Déployer
+
+Nous allons effectuer un test rapide en utilisant l'une des images Docker préconstruites :
+
+1. Rendez-vous dans **Workspaces** dans DevPod.
+2. Cliquez sur **Create Workspace**.
+3. Choisissez votre nouveau provider **AWS**.
+4. Choisissez votre IDE préféré (VS Code, etc.).
+5. À droite, sélectionnez un exemple de démarrage rapide (par exemple, Python). 🐍
+6. Cliquez sur **Create Workspace**.
+
+![new_worspace](new_worskapce.png#center)
+
+Attendez quelques instants, et votre environnement basé sur le cloud apparaîtra dans VS Code. 🎊
+
+![vscode](vscode.png#center)
+
+### Arrêter
+
+Lorsque vous n'utilisez pas l'environnement, cliquez sur **Stop** pour éteindre l'instance EC2. Vous ne paierez que pour le stockage — aucun temps de calcul. Idéal pour votre portefeuille. 💰
+
+![Stopped Instance](stopped_instance.png#center)
+
+### Supprimer
+
+Supprimer le workspace supprime toutes les ressources AWS associées à cet environnement, vous ne paierez donc pas un centime. Mais vous devrez redéployer si vous souhaitez l'utiliser à nouveau. ♻️
+
+![Delete Instance](delete_instance.png#center)
+
+## Conclusion 💡
+
+En combinant **DevContainers** et **DevPod** sur **AWS**, vous pouvez créer des environnements de développement flexibles et autogérés qui évoluent avec votre croissance — sans être enfermé dans des plateformes spécifiques à un fournisseur. Dites adieu aux problèmes du « Ça marche sur ma machine ! » et accueillez un codage sans friction. 🚀✨
+
+Amusez-vous bien ! 🎉

content/documentation/devpod/_index.md

@@ -0,0 +1,317 @@
+---
+title: "DevPod on AWS"
+date: 2025-02-11T20:00:00+02:00
+weight: 1
+cascade:
+  type: docs
+---
+
+## Sources
+
+- [DevPod](https://devpod.sh/docs/what-is-devpod) ⚙️
+- [DevContainer](https://containers.dev) 🐳
+
+## Introduction 🚀
+
+In this article, I’d like to showcase a fantastic tool that sits in the same family as GitPod and Codespaces: **DevPod**! It empowers you to create development environments effortlessly—without getting locked into any particular vendor. 🔒❌
+
+DevPod is based on **DevContainer** architecture and uses the specs found in a [devcontainer.json](https://containers.dev) file to spin up your dev setup. Personally, I love it for quickly and reliably deploying Network Labs with ContainerLab. 💻🧰
+
+## What a DevContainer Is 🤔
+
+A development container (often called a “dev container”) lets you use a container as a full-featured dev environment. (Check out the official [containers.dev documentation](https://containers.dev) for more details.)
+
+Let’s break it down:
+
+Have you ever heard the phrase “It works on my machine”? If you’re a developer, you’ve probably run headfirst into this problem when collaborating with others. But guess what? **DevContainers** solve the mystery of environment drift by providing consistent, reproducible Docker-based environments. Bye-bye setup headaches! 💆‍♀️
+
+Using DevContainers, you just need:
+
+1. A `.devcontainer` folder in your project.
+2. A `devcontainer.json` file that tells VS Code how to configure the container.
+3. Docker installed locally
+
+The backbone of the DevContainer is the `devcontainer.json` file. For example:
+
+```json
+{
+  "name": "Python DevContainer",
+  "image": "mcr.microsoft.com/devcontainers/python:3.10",
+  "features": {
+    "docker-in-docker": "latest"
+  },
+  "extensions": [
+    "ms-python.python",
+    "ms-azuretools.vscode-docker"
+  ]
+}
+```
+
+**What’s happening here?** 🕵️‍♀️
+
+- **"image"** – This uses a Python 3.10 environment that’s ready to go.
+- **"features"** – This adds Docker support inside the container.
+- **"extensions"** – Installs useful Python and Docker extensions in VS Code.
+
+DevContainers are awesome for local dev, but sometimes you need more muscle—maybe your workloads are huge, or you want to run specialized labs. That’s where **DevPod** comes in. 💪  
+**To be able to deployed lab easily on Cloud**
+
+## What DevPod Is 🤖
+
+**DevPod** is an open-source tool that lets you spin up dev environments either on your local machine or in the cloud of your choice. Imagine a self-hosted, super-customizable version of GitHub Codespaces. 🎉
+
+In my day-to-day networking escapades, I deploy ContainerLab-based setups with DevContainers on AWS. Let’s see how you can use DevPod to do exactly that (ContainerLab details will follow in another post, I promise!). 😜
+
+## AWS Provider 🌐
+
+DevPod uses **Providers**, which are like configuration modules that define where and how DevPod launches your environment. Here’s the Provider list:
+
+![Provider_list](provider.png#center)
+
+We’ll focus on the **AWS Provider**—though there are many config options:
+
+![Provider_list](aws_options.png#center)
+
+Before you freak out at all those toggles, don’t worry. If it’s just you tinkering, the defaults are usually fine. 🙌
+
+> [!NOTE] **Open Source Perks** 🎁
+>
+> Being open-source means you can pop the hood and see exactly how DevPod works. Check out the AWS code [here](https://github.com/loft-sh/devpod-provider-aws/tree/main) if you’re curious.
+
+## How the AWS Code Works
+
+Let’s break down what DevPod will do on AWS by looking at the [aws.go code](https://github.com/loft-sh/devpod-provider-aws/blob/main/pkg/aws/aws.go). From a high-level, it handles:
+
+1. **Initialization**: Reading configuration and setting up AWS SDK clients (with custom credentials if needed).
+2. **Networking**: Finding or creating the appropriate subnet, VPC, and security groups.
+3. **AMI Selection**: Choosing a suitable AMI (defaulting to a recent Ubuntu 22.04 image) and determining the root device.
+4. **IAM Setup**: Ensuring an appropriate instance role and instance profile exist, complete with policies.
+5. **Instance Lifecycle**: Creating, starting, stopping, checking status, and deleting instances.
+6. **User Data Injection**: Generating a script (embedded as Base64) that configures the instance (sets up users and SSH keys) on first boot.
+7. **Optional DNS**: Managing Route 53 records for the instance if the configuration calls for it.
+
+From my perspective, two points stand out as potentially the most critical:
+
+- **(#4) IAM Setup**
+- **(#6) User Data Injection**
+
+### Why are #4 and #6 “Tricky”?
+
+- **IAM Setup** is primarily handled by the `CreateDevpodInstanceProfile` function. It creates a role named `devpod-ec2-role` that can do the following:
+  - **EC2 Operations**: For example, it can describe or stop instances—particularly the instance associated with itself.
+  - **SSM Operations**: By attaching the AmazonSSMManagedInstanceCore policy, the instance can be managed by AWS Systems Manager.
+  - **KMS Operations (Optional)**: If configured, it can perform `kms:Decrypt` on a specific KMS key, helpful for handling session data or secrets.
+
+- **User Data Injection** is basically a startup script inserted into the instance as Base64. That script sets up a `devpod` user with sudo rights, creates SSH folders, and plops your public key in place. In the code, [it looks like](https://github.com/loft-sh/devpod-provider-aws/blob/9d2730c34ecee40cb42596c602381b92ad9c6682/pkg/aws/aws.go#L967-L980):
+
+```bash
+useradd devpod -d /home/devpod
+mkdir -p /home/devpod
+if grep -q sudo /etc/groups; then
+  usermod -aG sudo devpod
+elif grep -q wheel /etc/groups; then
+  usermod -aG wheel devpod
+fi
+
+echo "devpod ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/91-devpod
+mkdir -p /home/devpod/.ssh
+echo " + string(publicKey) + " >> /home/devpod/.ssh/authorized_keys
+chmod 0700 /home/devpod/.ssh
+chmod 0600 /home/devpod/.ssh/authorized_keys
+chown -R devpod:devpod /home/devpod
+```
+
+Since DevPod is open source, you can easily check this out yourself. It’s a great learning tool if you’re curious about the nuts and bolts! 🔩
+
+## IAM Roles and Policies
+
+You’ll need to set up an IAM user and attach an IAM policy that grants just enough permissions for DevPod. For example:
+
+- **EC2 Actions:**
+  - Describe: `ec2:DescribeSubnets`, `ec2:DescribeVpcs`, `ec2:DescribeImages`, `ec2:DescribeInstances`, `ec2:DescribeSecurityGroups`
+  - Manage Instances: `ec2:RunInstances`, `ec2:StartInstances`, `ec2:StopInstances`, `ec2:TerminateInstances`, `ec2:CancelSpotInstanceRequests`
+  - Security Groups & Tags: `ec2:CreateSecurityGroup`, `ec2:AuthorizeSecurityGroupIngress`, `ec2:CreateTags`
+- **IAM Actions:**
+  - `iam:GetInstanceProfile`, `iam:CreateRole`, `iam:PutRolePolicy`, `iam:AttachRolePolicy`, `iam:CreateInstanceProfile`, `iam:AddRoleToInstanceProfile`
+- **Route 53 (Optional):**
+  - `route53:ListHostedZones`, `route53:GetHostedZone`, `route53:ChangeResourceRecordSets`
+
+## AWS Configuration 🏗️
+
+I typically use the AWS web console to set this up, but you can absolutely do it all via CLI.
+
+### Step 1: Log in to the AWS Console
+
+1. Head to [AWS Management Console](https://aws.amazon.com/console/).
+2. Use an account with the proper rights to create IAM resources.
+
+### Step 2: Create a Custom IAM Policy
+
+#### **A. Go to the IAM Console**
+
+- In the AWS menu, find **IAM**.
+
+#### **B. Create a New Policy**
+
+1. Click **Policies** on the left.
+2. Press **Create policy**.
+
+#### **C. Switch to the JSON Tab**
+
+- Paste in something like this, adjusting if needed:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Sid": "EC2Actions",
+      "Effect": "Allow",
+      "Action": [
+        "ec2:DescribeSubnets",
+        "ec2:DescribeVpcs",
+        "ec2:DescribeImages",
+        "ec2:DescribeInstances",
+        "ec2:DescribeSecurityGroups",
+        "ec2:RunInstances",
+        "ec2:StartInstances",
+        "ec2:StopInstances",
+        "ec2:TerminateInstances",
+        "ec2:CancelSpotInstanceRequests",
+        "ec2:CreateSecurityGroup",
+        "ec2:AuthorizeSecurityGroupIngress",
+        "ec2:CreateTags",
+        "ec2:DeleteTags"
+      ],
+      "Resource": "*"
+    },
+    {
+      "Sid": "IAMActions",
+      "Effect": "Allow",
+      "Action": [
+        "iam:GetInstanceProfile",
+        "iam:CreateRole",
+        "iam:PutRolePolicy",
+        "iam:AttachRolePolicy",
+        "iam:CreateInstanceProfile",
+        "iam:AddRoleToInstanceProfile"
+      ],
+      "Resource": "*"
+    },
+    {
+      "Sid": "Route53Actions",
+      "Effect": "Allow",
+      "Action": [
+        "route53:ListHostedZones",
+        "route53:GetHostedZone",
+        "route53:ChangeResourceRecordSets"
+      ],
+      "Resource": "*"
+    }
+  ]
+}
+```
+
+- Click **Next** (tags optional), then **Next: Review**.
+
+#### **D. Review and Create**
+
+1. Name it `DevpodToolPolicy` (or whatever you like).
+2. Optional description.
+3. Click **Create policy**.
+
+### Step 3: Create/Update the IAM User
+
+#### **A. Create a New User (If Needed)**
+
+1. Click **Users** in IAM.
+2. **Add user**.
+3. Name it (e.g., `devpod-tool-user`).
+4. Choose **Programmatic access** if you want CLI access. 🤖
+5. **Next**.
+
+#### **B. Attach Your New Policy**
+
+1. On the permissions page, pick **Attach policies directly**.
+2. Check `DevpodToolPolicy`.
+3. Click **Create**.
+4. That’s it!
+
+### Step 4: Verify & Done
+
+Head back to **Users** → **devpod-tool-user** → **Permissions** to confirm `DevpodToolPolicy` is attached. ✅
+
+### Step 5: Use Those Credentials
+
+- If you created a programmatic user, make sure you note the **Access Key ID** and **Secret Access Key**.
+
+![devpod_user_sumup](devpod_user.png#center)
+
+**Bonus**: Keep track of your **VPC ID** (under the VPC service in AWS). You’ll need it when setting up DevPod.
+
+## Configure DevPod 🛠️
+
+### 1. Configure AWS Profile
+
+```bash
+aws configure --profile Devpod
+```
+
+When prompted:
+
+1. Access Key ID
+2. Secret Access Key
+3. Default region (e.g., `eu-west-1`)
+4. Output format (I usually leave it blank.)
+
+### 2. Add Profile to DevPod
+
+1. In DevPod, create a new provider and pick **AWS**.
+2. Select the **AWS region** (e.g., `eu-west-1`).
+3. Expand AWS options.
+4. **AWS Disk Size**: maybe 40GB to start.
+5. **Instance Type**: e.g., `t2.small`.
+6. **AWS Profile**: select `Devpod` (or the name you chose).
+7. **AWS VPC ID**: add your VPC.
+8. You can leave the rest as defaults.
+
+Click **Add Provider**.
+
+![added_new_provider](new_provider.png#center)
+
+## Testing a Deployment 🧪
+
+### Deploy
+
+We’ll run a quick test using one of the prebuilt Docker images:
+
+1. Go to **Workspaces** in DevPod.
+2. Click **Create Workspace**.
+3. Pick your new **AWS** provider.
+4. Choose your preferred IDE (VS Code, etc.).
+5. On the right, pick a quickstart example (e.g., Python). 🐍
+6. Click **Create Workspace**.
+
+![new_worspace](new_worskapce.png#center)
+
+Wait a few moments, and your cloud-based environment will pop up in VS Code. 🎊
+
+![vscode](vscode.png#center)
+
+### Stop
+
+When you’re not using it, click **Stop** to shut down the EC2 instance. You’ll only pay for storage—no compute time. Great for the wallet. 💰
+
+![Stopped Instance](stopped_instance.png#center)
+
+### Delete
+
+Deleting the workspace removes all AWS resources for that environment, so you won’t pay a dime. But you’ll have to redeploy if you want to use it again. ♻️
+
+![Delete Instance](delete_instance.png#center)
+
+## Conclusion 💡
+
+By combining **DevContainers** and **DevPod** on **AWS**, you can build flexible, self-managed dev environments that scale as you grow—without getting boxed in by vendor-specific platforms. Wave goodbye to “It works on my machine!” woes, and say hello to frictionless coding. 🚀✨
+
+Happy building and exploring! 🎉