diff --git a/managed-services/iot-hub/api-cli/connecting-twins-to-grafana-cloud.mdx b/managed-services/iot-hub/api-cli/connecting-twins-to-grafana-cloud.mdx
deleted file mode 100644
index 58a7898ee0..0000000000
--- a/managed-services/iot-hub/api-cli/connecting-twins-to-grafana-cloud.mdx
+++ /dev/null
@@ -1,233 +0,0 @@
----
-meta:
-  title: How to connect IoT Cloud Twins to Grafana Cloud
-  description: This tutorial shows how to connect Cloud Twins to a graphite instance on Grafana Cloud.
-content:
-  h1: How to connect IoT Cloud Twins to Grafana Cloud
-  paragraph: This tutorial shows how to connect Cloud Twins to a graphite instance on Grafana Cloud.
-totalTime: PT15M
-tags: iot iot-hub mqtt twins cloud-twins grafana grafana-cloud graphite
-categories:
-  - managed-services
----
-
-<Macro id="iam-requirements" />
-
-
-This tutorial will show how to connect Cloud Twins to a Graphite instance on Grafana Cloud. This allows you to monitor and view events on your Cloud Twin (updates or modifications of its document's values).
-
-<Message type="note">
-  The twins feature is currently in **beta** status.
-</Message>
-
-<Message type="requirement">
-  - You have an account and are logged into [the Scaleway console](https://console.scaleway.com)
-  - You have installed [curl](https://curl.se/) and [`jq` (JSON parsing tool)](https://stedolan.github.io/jq/) on your local computer
-  - You have [created an IoT Hub](/managed-services/iot-hub/how-to/create-hub/)
-  - You have [added a device](/managed-services/iot-hub/how-to/add-device/)
-  - You have [created a Grafana Cloud account](https://grafana.com/products/cloud/)
-  - Your Device allows insecure connections
-</Message>
-
-<Message type="note">
-  When designing a production system, you should `Deny Insecure` connections to have the highest level of security.
-</Message>
-
-Configure the following variables from a terminal on your local computer:
-
-```bash
-IOT_API="https://api.scaleway.com/iot/v1/regions/fr-par"
-SCW_SECRET_KEY="<your scaleway API secret key here>"
-SCW_PROJECT="<your project ID here>"
-HUB_ID="<the hub_id of the hub you created>"
-DEVICE_ID="<the device_id of the device you added>"
-```
-
-## Connect your hub to Grafana Cloud
-
-1. Recover your username under `user identifier` on the Grafana [credentials page](https://grafana.com/orgs/user-identifier/api-keys).
-2. Generate a MetricsPublisher key and store the returned token (`GRAPHITE_TOKEN`).
-    <Message type="tip">
-      See [Create a Grafana Cloud API key](https://grafana.com/docs/grafana-cloud/reference/create-api-key/) for details.
-    </Message>
-3. Go to your Grafana instance: `https://user-identifier.grafana.net/`, where `user-identifier` is your username.
-4. Go to the graphite configuration panel:
-    - Select **Configuration**, then **Data sources** in the menu (A)
-    - Select Graphite on the list (B)
-
-    <Lightbox src="grafanacloud-configuration-datasource-menu-graphite.webp" alt="" />
-5. Get the following information from the Graphite configuration panel:
-    - In the `HTTP` box, find the `URL` value and note the host part (`GRAPHITE_HOST`, `graphite-us-central1.grafana.net` in the example) (A)
-    - In the `Auth` box, find the `Basic Auth Details` and note the user (a number as your `GRAPHITE_USERID`) (B)
-
-    <Lightbox src="grafanacloud-datasource-graphite-settings.webp" alt="" />
-6. Construct the `push_uri` as follows:
-    ```
-    https://GRAPHITE_USERID:GRAPHITE_TOKEN@GRAPHITE_HOST/metrics
-    ```
-
-    So it should look like:
-    ```
-    https://12345:SecReTApiKEyVaLuE@graphite-us-central1.grafana.net/metrics
-    ```
-7. Set the graphite `push_uri` in your hub's configuration:
-    <Message type="note">
-      This beta feature is only available in [the API](https://www.scaleway.com/en/developers/api/iot/).
-    </Message>
-
-    ```bash
-    curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PATCH $IOT_API/hubs/$HUB_ID -d '{
-      "twins_graphite_config": {
-        "push_uri": "https://'$GRAPHITE_USERID':'$GRAPHITE_TOKEN'@'$GRAPHITE_HOST'/metrics"
-        }
-      }'
-    ```
-
-The Hub is now connected to Grafana cloud.
-
-## Using the Twin with Grafana
-
-Now, we will consider our Cloud Twin itself. We'll look at its document format, create a config file, and make several modifications to the document store, so that we can then see how these are logged in Grafana.
-
-In our example the Cloud Twin's document format is as follows:
-
-```json
-{
-    "state": {
-        "enable": true,
-        "value": 12.5,
-        "text": "ignored"
-    },
-    "data": {
-        "value": 7.5,
-        "in error": false
-    }
-}
-```
-
-### Set the configuration document
-
-In this example we want to trace:
-- any write on the `state` (even when setting the same value twice)
-- changes on the `data` part of the document
-We therefore add a tag to those values in order to recover them easily in Grafana.
-
-The `_config` document will be:
-```json
-{
-    "documents": {
-        "current": {
-            "state": {"_tsdb_trigger": "on-update"},
-            "data": {"_tsdb_trigger": "on-change"},
-            "_tags": {
-                "source": "graphite-tutorial"
-            }
-        }
-    }
-}
-```
-
-Set the config document to the required format using the API as follows:
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$DEVICE_ID/documents/_config -d '{
-    "data": {
-      "documents": {
-        "current": {
-    "state": {"_tsdb_trigger": "on-update"},
-    "data": {"_tsdb_trigger": "on-change"},
-    "_tags": {
-      "source": "graphite-tutorial"
-    }
-        }
-      }
-    }
-	}' | jq
-	```
-
-### Simulate some events
-1. Create the twin document
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$DEVICE_ID/documents/current -d '{
-    "data": {
-      "state": {
-        "enable": false,
-        "text": "ignored"
-      }
-    }
-	}' | jq
-	```
-2. Change it
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$DEVICE_ID/documents/current -d '{
-    "data": {
-      "state": {
-        "enable": true,
-        "value": 12.5,
-        "text": "ignored"
-      },
-      "data": {
-        "value": 7.5,
-        "in error": false
-      }
-    }
-	}' | jq
-	```
-3. Update only the `data` section using patch
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PATCH $IOT_API/twins/$DEVICE_ID/documents/current -d '{
-    "data": {
-      "data": {
-        "value": 12.5
-      }
-    }
-	}' | jq
-	```
-4. Set the whole document again, without changing anything
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$DEVICE_ID/documents/current -d '{
-    "data": {
-      "state": {
-        "enable": true,
-        "value": 12.5,
-        "text": "ignored"
-      },
-      "data": {
-        "value": 12.5,
-        "in error": false
-      }
-    }
-	}' | jq
-	```
-
-### Show the event in Grafana
-We can now return to Grafana to see how all the modifications to our twin have been logged.
-
-1. Go to your Grafana instance explore panel
-    - select Explore (A)
-    - ensure the graphite source is selected (B)
-    - click on the pen to switch to the query editor (C)
-    <Lightbox src="grafanacloud-explore.webp" alt="" />
-2. View your data
-    - enter the query (A)
-    ```
-    groupByTags(seriesByTag('source=graphite-tutorial'), 'last', 'json_path', 'name')
-    ```
-    - adjust the time range if needed (B)
-    - see your data (C)
-    <Lightbox src="grafanacloud-explore-data.webp" alt="" />
-3. If you prefer lines to dots, you can use the `keepLastValue` graphite function.
-
-    Replace the query with:
-    ```
-    groupByTags(keepLastValue(seriesByTag('source=graphite-tutorial'), inf), 'last', 'json_path', 'name')
-    ```
-
-<Message type="tip">
-  You can create a dashboard in Grafana and use similar queries in your panel.
-</Message>
-
-
-<Navigation title="See Also">
-  <PreviousButton to="/managed-services/iot-hub/api-cli/using-twins/">Using Cloud Twins</PreviousButton>
-  <NextButton to="/managed-services/iot-hub/api-cli/migrating-from-api-v1beta1/">Migrating from Scaleway IoT Hub API v1beta1</NextButton>
-</Navigation>
diff --git a/managed-services/iot-hub/api-cli/using-twins.mdx b/managed-services/iot-hub/api-cli/using-twins.mdx
deleted file mode 100644
index 6bc8698dc1..0000000000
--- a/managed-services/iot-hub/api-cli/using-twins.mdx
+++ /dev/null
@@ -1,262 +0,0 @@
----
-meta:
-  title: Using IoT Cloud Twins
-  description: This page shows you how to use the Cloud Twins through both REST and inband MQTT API.
-content:
-  h1: Using IoT Cloud Twins
-  paragraph: This page shows you how to use the Cloud Twins through both REST and inband MQTT API.
-totalTime: PT15M
-tags: iot iot-hub mqtt cloud-twins cloud twins rest
-categories:
-  - managed-services
----
-
-This page shows you how to use [Cloud Twins](/managed-services/iot-hub/concepts/#twins) through both REST and inband MQTT API. We will use the example of a Device consisting of an internet-enabled alarm control panel with a siren and door sensor, managed by a smartphone application. We show:
-  - how to use a Cloud Twin to store information when a user arms (activates) the alarm from their smartphone 
-  - how the Device can use the same Cloud Twin to store information about whether its door sensor has detected an open door and whether its siren is ringing in a 'current state' document
-  - how the Device can send requests to read the 'desired' documents in its Cloud Twin, compute new states for itself based on the information it receives and collects, and write new updated data to the 'current' Cloud Twin document.
-
-<Macro id="iam-requirements" />
- 
-<Message type="requirement">
-  - You have an account and are logged into [the Scaleway console](https://console.scaleway.com)
-  - You have installed [curl](https://curl.se/) and [`jq` (JSON parsing tool)](https://stedolan.github.io/jq/) on your local computer
-  - You have [created an IoT Hub](/managed-services/iot-hub/how-to/create-hub)
-  - You have [added a device](/managed-services/iot-hub/how-to/add-device)
-  - Your device allows insecure connections
-</Message>
-
-<Message type="note">
-  For more information, refer to [our documentation about Cloud Twins](/managed-services/iot-hub/reference-content/twins/).
-</Message>
-
-<Message type="important">
-  The Cloud Twins feature is currently in **beta** status.
-</Message>
-
-## Understanding Cloud Twins 
-
-### Internet Alarm Control Panel
-
-In the following example, you have an internet-enabled alarm control panel with a door sensor and a siren. 
-
-Be aware that:
-
-- The siren will sound when the door is opened only if the system is armed.
-- If the power is cut and restored, the system should be armed/disarmed as previously set.
-- The app on your smartphone should be able to display if your door is open. If your alarm system is not reachable, the app should display the last known state and the last time this state was updated.
-
-The control panel is one device and uses the inband MQTT API to communicate with its twin.
-
-The smartphone application uses the REST API to access directly the control panel twin.
-
-### Cloud Twin Documents
-
-The twin represents the panel's current state and the desired states using two documents:
-
-- The `desired` document: represents the wanted state as controlled from the application to arm/disarm the alarm. It is written by the application and read by the device.
-
-**Example** 
-
-```json
-{
-    "alarm_armed": true
-}
-```
-
-- The `current` document: represents the actual state of the alarm panel including its door sensor and siren. It is written by the device and read by the application.
-
-**Example** 
-
-```json
-{
-    "last_update":   "<time>",
-    "alarm_armed":   false,
-    "siren_ringing": false,
-    "door_open":     true
-}
-```
-
-As each document has a single writer, we do not need to handle any concurrency and can send documents without version information.
-
-## Creating the resources
-
-<Message type="note">
-  In production, you should `Deny Insecure` connections to have the highest level of security.
-</Message>
-
-Set the following variables:
-
-```bash
-IOT_API="https://api.scaleway.com/iot/v1/regions/fr-par"
-SCW_SECRET_KEY="<your scaleway token secret here>"
-SCW_PROJECT="<your project ID here>"
-PANEL_DEVICE_ID="<the device_id of the device you created>"
-```
-
-### Understanding Device behavior
-
-To receive responses to its inband API call, the device will subscribe to the response topics: `$SCW/twins/me/#`.
-
-The device will perform the following tasks:
-
-1. Sending the request to read the `desired` document and publishing `$SCW/twins/me/desired/get`
-2. Storing the new state internally when the response arises on `$SCW/twins/me/desired/get/response/success`,
-3. Reading the door sensor and storing it internally.
-4. Computing the siren state depending on the internal state, and storing the new `siren_ringing` state internally.
-5. Updating the update time internally.
-6. Publishing the internal state to the `current` document, using `$SCW/twins/me/current/put`, with the document as payload, for example:
-	```json
-	{
-	  "data":{
-	    "last_update":   "<time>",
-	    "alarm_armed":   false,
-	    "siren_ringing": false,
-	    "door_open":     true
-	  }
-	}
-	```
-7. Repeating the process.
-    <Message type="note">
-      This is a minimalistic description, some steps could be done asynchronously.
-    </Message>
-
-<Message type="tip">
-  To manually test this you can use our [webclient](https://webclient.iot.fr-par.scw.cloud/?host=websocket.iot.fr-par.scw.cloud). Use the link on your device page and it will connect you directly. The device must accept insecure connections to use the webclient.
-</Message>
-
-### Understanding Application behavior
-
-The application will use the REST API.
-
-1. It will read the `current` document and use it to display its user interface.
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" $IOT_API/twins/$PANEL_DEVICE_ID/documents/current | jq
-	```
-2. When the user toggles the `armed` button, it will send the new `desired` document.
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$PANEL_DEVICE_ID/documents/desired -d '{
-	  "data": {
-	    "alarm_armed": true
-	  }
-	}' | jq
-	```
-
-## Setting up partial updates
-
-Instead of pushing the full document each time, you might want to update only the part that changed.
-This is particularly useful if your document is large.
-
-To do so, you can use the `patch` command.
-
-Continuing the previous example, if you want to only update the `last_update` time and `door_open` state you will publish on the `$SCW/twins/me/current/patch` topic with the following patch document as a payload:
-```json
-{
-  "data":{
-    "last_update":   "<new_time>",
-    "door_open":     false
-  }
-}
-```
-
-## Enabling concurrency
-
-Consider a single document accessed by several actors. In this case, you can add a constraint so that one actor does not discard data added by another.
-
-The first solution is to use different keys and the `patch` method (see above).
-
-The second solution is to use optimistic locking through version numbers.
-
-When modifying a document(`put` or `patch`) the user sends the current version along with the new data.
-
-- If the version matches the one in the twin, the change is applied.
-- If it does not match, an error is returned, and the user can then fetch the document (`get`), compute the modification again and send it.
-
-### REST API
-
-1. Create a document. This is version 1.
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$PANEL_DEVICE_ID/documents/concurency -d '{
-	  "data": {
-	    "test_value": "initial"
-	  }
-	}' | jq
-	```
-2. Update the document. 
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$PANEL_DEVICE_ID/documents/concurency -d '{
-	  "version": 1,
-	  "data": {
-	    "test_value": "first actor"
-	  }
-	}' | jq
-	```
-	The updated document becomes version 2 (as shown in the output below).
-
-	```json
-	{
-	  "twin_id": "<your id>",
-	  "document_name": "concurency",
-	  "version": 2,
-	  "data": {
-	    "test_value": "first actor"
-	  }
-	}
-	```
-	Suppose that a second user runs the same call 'almost' simultaneously, without noticing that version 2 already existed, and tries to update version 1 again:
-	```bash
-	curl -sS -H "X-Auth-Token: $SCW_SECRET_KEY" -X PUT $IOT_API/twins/$PANEL_DEVICE_ID/documents/concurency -d '{
-	  "version": 1,
-	  "data": {
-	    "test_value": "second actor"
-	  }
-	}' | jq
-	```
-The output returned, in this case, is an invalid version argument.
-
-<Message type="tip">
-  As the patch format does not handle arrays, this trigger can be used to update arrays concurrently.
-</Message>
-
-### Inband MQTT API
-
-Concurrency can also be set up with the inband MQTT API. 
-
-1. Follow steps 1 and 2 from the previous section.
-1. Open the webclient.
-2. Subscribe to the `$SCW/twins/me/#` topic.
-3. Publish the following payload on the `$SCW/twins/me/concurency/put` topic:
-	```json
-	{
-	  "version": 1,
-	  "data": {
-	    "test_value": "MQTT actor"
-	  }
-	}
-	```
-	The response is once again a version error.
-	```json
-	{
-	  "error": "document version mismatch",
-	  "twin_id": "<your twin id>",
-	  "document_name": "concurency",
-	  "expected_version": 1,
-	  "actual_version": 2
-	}
-	```
-4. Publish the right version with the following payload:
-	```json
-	{
-	  "version": 2,
-	  "data": {
-	    "test_value": "MQTT actor"
-	  }
-	}
-	```
-	The new document updated to version 3.
-
-
-<Navigation title="See Also">
-  <PreviousButton to="/managed-services/iot-hub/api-cli/cli-db-tips-tricks/">Discovering IoT Hub Database route tips & tricks</PreviousButton>
-  <NextButton to="/managed-services/iot-hub/api-cli/connecting-twins-to-grafana-cloud/">Connecting IoT Cloud Twins to Grafana Cloud</NextButton>
-</Navigation>
diff --git a/menu/navigation.json b/menu/navigation.json
index c83e4b0917..a1d4c2a77a 100644
--- a/menu/navigation.json
+++ b/menu/navigation.json
@@ -1166,6 +1166,20 @@
                 "label": "How to",
                 "slug": "how-to"
               },
+              {
+                "items": [
+                  {
+                    "label": "Create and deploy a container with the Scaleway API",
+                    "slug": "deploy-container-api"
+                  },
+                  {
+                    "label": "Create and deploy a container with the Scaleway CLI",
+                    "slug": "deploy-container-cli"
+                  }
+                ],
+                "label": "API/CLI",
+                "slug": "api-cli"
+              },
               {
                 "items": [
                   {
@@ -2890,14 +2904,6 @@
                     "label": "Discovering IoT Hub Database Route Tips and Tricks",
                     "slug": "cli-db-tips-tricks"
                   },
-                  {
-                    "label": "Using Cloud Twins",
-                    "slug": "using-twins"
-                  },
-                  {
-                    "label": "Connecting IoT Cloud Twins to Grafana Cloud",
-                    "slug": "connecting-twins-to-grafana-cloud"
-                  },
                   {
                     "label": "Migrating from the IoT API v1beta1",
                     "slug": "migrating-from-api-v1beta1"
diff --git a/serverless/containers/api-cli/deploy-container-api.mdx b/serverless/containers/api-cli/deploy-container-api.mdx
new file mode 100644
index 0000000000..049ca8f2c1
--- /dev/null
+++ b/serverless/containers/api-cli/deploy-container-api.mdx
@@ -0,0 +1,89 @@
+---
+meta:
+  title: How to create and deploy a container with the Scaleway API
+  description: This page explains how to create and deploy a Serverless Container with the Scaleway API
+content:
+  h1: How to create and deploy a container with the Scaleway API
+  paragraph: This page explains how to create and deploy a Serverless Container with the Scaleway API
+tags: containers api deploy
+dates:
+  validation: 2023-08-18
+  posted: 2021-08-18
+categories:
+  - serverless
+---
+
+The Scaleway API allows you to create and manage all your Scaleway resources programmatically. Anything you can do through the [Scaleway console](https://www.console.scaleway.com)
+can also be done through the API. 
+
+Refer to the [Scaleway Developers website](https://www.scaleway.com/en/developers/api/) for more information on the Scaleway API.
+
+<Macro id="iam-requirements" />
+
+<Message type="requirement">
+  - You have an account and are logged into the [Scaleway console](https://console.scaleway.com)
+  - You have [configured your API key](/identity-and-access-management/iam/how-to/create-api-keys/)
+  - You have installed [curl](https://curl.se/download.html)
+  - You have [made your first request](https://www.scaleway.com/en/developers/api/#quickstart:-first-request) using the Scaleway API
+</Message>
+
+1. Run the following command in your terminal to create a containers namespace:
+
+    ```json
+    curl -X POST \
+    -H "X-Auth-Token: $SCW_SECRET_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{
+        "name": "<YOUR_NAMESPACE_NAME>",
+        "project_id": "YOUR_PROJECT_ID"
+    }' \
+    "https://api.scaleway.com/containers/v1beta1/regions/fr-par/namespaces"
+    ```
+
+    An output similar to the following displays:
+
+    ```json
+    {"id":"example-fb93-43e3-a036-7be69f1af7a1", "name":"your-namespace-name", "environment_variables":{}, "organization_id":"example-776f-4f65-a41e-6c5fc58b4076", "project_id":"example-c162-43f7-bb3e-1182e6f12342", "status":"pending", "registry_namespace_id":"", "error_message":null, "registry_endpoint":"", "description":"", "secret_environment_variables":[], "region":"fr-par"}%  
+    ```
+
+2. Run the following command to create a container:
+
+    ```json
+    curl -X POST \
+    -H "X-Auth-Token: $SCW_SECRET_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{
+      "name": "<YOUR_CONTAINER_NAME>",
+      "namespace_id": "<YOUR_NAMESPACE_ID>",
+      "runtime": "<RUNTIME>"
+    }' \
+    "https://api.scaleway.com/containers/v1beta1/regions/fr-par/containers"
+    ```
+
+    An output similar to the following displays:
+
+    ```json
+    {"id":"ef777a64-1f4e-4d43-8227-26927c7de057", "name":"your-container-name", "namespace_id":"example-fb93-43e3-a036-7be69f1af7a1", "status":"created", "environment_variables":{}, "min_scale":0, "max_scale":5, "runtime":"python310", "memory_limit":256, "cpu_limit":140, "timeout":"300s", "handler":"handler.handle", "error_message":null, "privacy":"public", "description":"", "domain_name":"namespaceg04rnwx-container-example.containers.cnt.fr-par.scw.cloud", "secret_environment_variables":[], "http_option":"enabled", "runtime_message":"", "build_message":null, "region":"fr-par"}% 
+    ```
+
+    <Message type="note">
+      For testing purposes, you can use the `"registry_image": "nginx:latest"` and `"port": "80"` parameters to quickly create a container.
+    </Message>
+
+3. Run the following command to deploy your container:
+
+    ```json
+    curl -X POST \
+      -H "X-Auth-Token: $SCW_SECRET_KEY" \
+      -H "Content-Type: application/json" \
+      -d '{}' \
+      "https://api.scaleway.com/containers/v1beta1/regions/fr-par/containers/<YOUR_CONTAINER_ID>/deploy"
+    ```
+    The deployment process can take several minutes depending on the image used.
+4. Run the following command to call your container once it is deployed:
+
+    ```bash
+    curl <YOUR_CONTAINER_ENDPOINT>
+    ```
+
+    Your container is now deployed and ready to use.
\ No newline at end of file
diff --git a/serverless/containers/api-cli/deploy-container-cli.mdx b/serverless/containers/api-cli/deploy-container-cli.mdx
new file mode 100644
index 0000000000..cd5edbcb69
--- /dev/null
+++ b/serverless/containers/api-cli/deploy-container-cli.mdx
@@ -0,0 +1,157 @@
+---
+meta:
+  title: How to create and deploy a container with the Scaleway CLI
+  description: This page explains how to create and deploy a Serverless Container with the Scaleway CLI
+content:
+  h1: How to create and deploy a container with the Scaleway CLI
+  paragraph: This page explains how to create and deploy a Serverless Container with the Scaleway CLI
+tags: containers cli deploy
+dates:
+  validation: 2023-08-18
+  posted: 2021-08-18
+categories:
+  - serverless
+---
+
+## Scaleway Command Line Interface Overview
+
+[The Scaleway Command Line Interface (CLI)](https://github.com/scaleway/scaleway-cli) allows you to pilot your Scaleway infrastructure directly from your terminal, providing a faster way to administer and monitor your resources. Scaleway CLI is easy to set up and use, and an essential tool for operating efficiently in your cloud environment. The CLI provides many functionalities, including the ability to create and deploy Serverless Containers.
+
+<Macro id="iam-requirements" />
+
+<Message type="requirement">
+  - You have an account and are logged into the [Scaleway console](https://console.scaleway.com)
+  - You have [configured your SSH key](/console/project/how-to/create-ssh-key/)
+  - You have [generated your API key](/identity-and-access-management/iam/how-to/create-api-keys/)
+  - You have [downloaded and installed the Scaleway CLI](https://github.com/scaleway/scaleway-cli)
+</Message>
+
+## Configuring the CLI
+
+1. Open a terminal and type the following command to configure the Scaleway CLI on your machine:
+
+    ```bash
+    scw init
+    ```
+
+    If you have already configured the CLI, you will see a message like the following:
+
+    ```
+    Current config is located at /path/to/config.yaml
+    access_key: your-access-key
+    secret_key: your-secret-key
+    default_organization_id: ID-of-your-organization
+    default_project_id: ID-of-your-project
+    default_region: your-default-region (fr-par)
+    default_zone: your-default-zone (fr-par-1)
+
+    Do you want to override the current config? (Y/n):
+    ```
+
+2. Type `n` and go directly to the [Creating a container](#creating-a-container) step of this procedure if you do not want to edit your configuration.
+
+    If you have not yet configured the CLI, you will be guided through the configuration process via a series of questions:
+
+    ```
+    Enter a valid secret-key or an email
+    ```
+
+3. Enter either the email address for your account (you will then be asked for your password), or your [API secret key](/console/project/how-to/create-ssh-key):
+
+    ```
+    To improve this tool we rely on diagnostic and usage data.
+    Sending such data is optional and can be disabled at any time by running "scw config set send-telemetry=false".
+    Do you want to send usage statistics and diagnostics? (Y/n):
+    ```
+
+    Type `y` or `n`.
+
+    ```
+    To fully enjoy Scaleway CLI we recommend you install autocomplete support in your shell.
+    Do you want to install autocomplete? (Y/n):
+    ```
+
+    Type `y` or `n`.
+
+    ```
+    To enable autocomplete, scw needs to update your shell configuration.
+    What type of shell are you using (default: zsh):
+    ```
+
+4. Press enter if the default shell type displayed is the one you are using. Otherwise, enter the correct shell type you are using. This should complete the configuration process:
+
+    ```
+    Initialization completed with success.
+    ```
+
+## Creating a container
+
+1. Run the following command in your terminal to create a containers namespace:
+
+    ```bash
+    scw container namespace create name=<YOUR_NAMESPACE_NAME>
+    ```
+
+    An output similar to the following displays:
+    
+    ```
+    ID                   6e74dbb7-9323-46bb-abc7-5c0105f4e70e
+    Name                 <YOUR_NAMESPACE_NAME>
+    OrganizationID       55e28409-776f-4f65-a41e-6c5fc58b4076
+    ProjectID            55e28409-776f-4f65-a41e-6c5fc58b4076
+    Status               pending
+    RegistryNamespaceID  -
+    RegistryEndpoint     -
+    Description          -
+    Region               fr-par
+    ```
+
+2. Run the following command in your terminal to create a container:
+
+    ```bash
+    scw container container create name=<CONTAINER_NAME> namespace-id=<NAMESPACE_ID> registry-image=<IMAGE_REGISTRY_URL>
+    ```
+
+    An output similar to the following displays:
+
+    ```
+    ID              717fb5f9-95c3-4c0b-84db-2321283e46dc
+    Name            <CONTAINER_NAME>
+    NamespaceID     cee31af8-d43e-4078-8f55-c921a9311f47
+    Status          created
+    MinScale        0
+    MaxScale        5
+    Runtime         python310
+    MemoryLimit     256
+    CPULimit        140
+    Timeout         5 minutes
+    Handler         handler.handle
+    Privacy         public
+    Description     -
+    DomainName      namespace0leshy-cli-fn-containername.containers.fnc.fr-par.scw.cloud
+    Region          fr-par
+    HTTPOption      enabled
+    RuntimeMessage  -
+    ```
+
+    <Message type="note">
+      For testing purposes, you can use the `registry-image=nginx:latest` and `port=80` parameters to quickly create a container.
+    </Message>
+
+## Deploying a container
+
+1. Run the following command to deploy your container with the zip archive you just created:
+
+    ```bash
+    scw container container deploy <CONTAINER_ID>
+    ```
+
+    The deployment process can take several minutes depending on the image used.
+
+2. Run the following command to call your container:
+
+    ```bash
+    curl <YOUR_CONTAINER_ENDPOINT>
+    ```
+
+    Your container is now deployed and ready to be used.
diff --git a/serverless/containers/api-cli/index.mdx b/serverless/containers/api-cli/index.mdx
new file mode 100644
index 0000000000..df683c8673
--- /dev/null
+++ b/serverless/containers/api-cli/index.mdx
@@ -0,0 +1,8 @@
+---
+meta:
+  title: Serverless Containers - API/CLI Documentation
+  description: Serverless Containers API/CLI Documentation
+content:
+  h1: Serverless Containers API/CLI Documentation
+  paragraph: Serverless Containers API/CLI Documentation
+---
diff --git a/serverless/functions/api-cli/deploy-function-api.mdx b/serverless/functions/api-cli/deploy-function-api.mdx
index 175ea05849..a983f004be 100644
--- a/serverless/functions/api-cli/deploy-function-api.mdx
+++ b/serverless/functions/api-cli/deploy-function-api.mdx
@@ -1,7 +1,7 @@
 ---
 meta:
   title: How to create and deploy a function with the Scaleway API
-  description: This page explains how to create and deploy a serverless function with the Scaleway API
+  description: This page explains how to create and deploy a Serverless Function with the Scaleway API
 content:
   h1: How to create and deploy a function with the Scaleway API
   paragraph: This page explains how to create and deploy a serverless function with the Scaleway API
@@ -29,85 +29,85 @@ Refer to the [Scaleway Developers website](https://www.scaleway.com/en/developer
 
 1. Run the following command in your terminal to create a functions namespace:
 
-  ```json
-  curl -X POST \
-  -H "X-Auth-Token: $SCW_SECRET_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-      "name": "<YOUR_NAMESPACE_NAME>",
-      "project_id": "YOUR_PROJECT_ID"
-  }' \
-  "https://api.scaleway.com/functions/v1beta1/regions/fr-par/  namespaces"
-  ```
+    ```json
+    curl -X POST \
+    -H "X-Auth-Token: $SCW_SECRET_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{
+        "name": "<YOUR_NAMESPACE_NAME>",
+        "project_id": "YOUR_PROJECT_ID"
+    }' \
+    "https://api.scaleway.com/functions/v1beta1/regions/fr-par/  namespaces"
+    ```
 
-  An output similar to the following displays:
+    An output similar to the following displays:
 
-  ```json
-  {"id":"example-fb93-43e3-a036-7be69f1af7a1", "name":"your-namespace-name", "environment_variables":{}, "organization_id":"example-776f-4f65-a41e-6c5fc58b4076", "project_id":"example-c162-43f7-bb3e-1182e6f12342", "status":"pending", "registry_namespace_id":"", "error_message":null, "registry_endpoint":"", "description":"", "secret_environment_variables":[], "region":"fr-par"}%  
-  ```
+    ```json
+    {"id":"example-fb93-43e3-a036-7be69f1af7a1", "name":"your-namespace-name", "environment_variables":{}, "organization_id":"example-776f-4f65-a41e-6c5fc58b4076", "project_id":"example-c162-43f7-bb3e-1182e6f12342", "status":"pending", "registry_namespace_id":"", "error_message":null, "registry_endpoint":"", "description":"", "secret_environment_variables":[], "region":"fr-par"}%  
+    ```
 
 2. Run the following command to create a function:
 
-  ```json
-  curl -X POST \
-  -H "X-Auth-Token: $SCW_SECRET_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "name": "<YOUR_FUNCTION_NAME>",
-    "namespace_id": "<YOUR_NAMESPACE_ID>",
-    "runtime": "<RUNTIME>"
-  }' \
-  "https://api.scaleway.com/functions/v1beta1/regions/fr-par/functions"
-  ```
+    ```json
+    curl -X POST \
+    -H "X-Auth-Token: $SCW_SECRET_KEY" \
+    -H "Content-Type: application/json" \
+    -d '{
+      "name": "<YOUR_FUNCTION_NAME>",
+      "namespace_id": "<YOUR_NAMESPACE_ID>",
+      "runtime": "<RUNTIME>"
+    }' \
+    "https://api.scaleway.com/functions/v1beta1/regions/fr-par/functions"
+    ```
 
-  An output similar to the following displays:
+    An output similar to the following displays:
 
-  ```json
-  {"id":"ef777a64-1f4e-4d43-8227-26927c7de057", "name":"your-function-name", "namespace_id":"example-fb93-43e3-a036-7be69f1af7a1", "status":"created", "environment_variables":{}, "min_scale":0, "max_scale":5, "runtime":"python310", "memory_limit":256, "cpu_limit":140, "timeout":"300s", "handler":"handler.handle", "error_message":null, "privacy":"public", "description":"", "domain_name":"namespaceg04rnwx-function-example.functions.fnc.fr-par.scw.cloud", "secret_environment_variables":[], "http_option":"enabled", "runtime_message":"", "build_message":null, "region":"fr-par"}%  
-  ```
+    ```json
+    {"id":"ef777a64-1f4e-4d43-8227-26927c7de057", "name":"your-function-name", "namespace_id":"example-fb93-43e3-a036-7be69f1af7a1", "status":"created", "environment_variables":{}, "min_scale":0, "max_scale":5, "runtime":"python310", "memory_limit":256, "cpu_limit":140, "timeout":"300s", "handler":"handler.handle", "error_message":null, "privacy":"public", "description":"", "domain_name":"namespaceg04rnwx-function-example.functions.fnc.fr-par.scw.cloud", "secret_environment_variables":[], "http_option":"enabled", "runtime_message":"", "build_message":null, "region":"fr-par"}%  
+    ```
 
 3. Create a zip file containing your function's code by following [this procedure](/serverless/functions/how-to/package-function-dependencies-in-zip/).
 
-  <Message type="note">
-    For testing purposes, you can create a zip archive with a simple Python file named `handler.py` inside, that contains the following code:
-
-    ```python
-    def handle(event, context):
-    return {
-        "body": {
-            "message": 'Hello, world',
-        },
-        "statusCode": 200,
-    }
-    ```
-  </Message>
+    <Message type="note">
+      For testing purposes, you can create a zip archive with a simple Python file named `handler.py` inside, that contains the following code:
+
+      ```python
+      def handle(event, context):
+      return {
+          "body": {
+              "message": 'Hello, world',
+          },
+          "statusCode": 200,
+      }
+      ```
+    </Message>
 
 4. Upload your zip file [using the Scaleway console](/serverless/functions/how-to/package-function-dependencies-in-zip/#how-to-upload-your-zip-file-to-the-scaleway-console) or [using the Scaleway API](/serverless/functions/how-to/package-function-dependencies-in-zip/#how-to-upload-your-zip-file-using-the-scaleway-api).
 
 5. Run the following command to deploy your function:
 
-  ```json
-  curl -X POST \
-    -H "X-Auth-Token: $SCW_SECRET_KEY" \
-    -H "Content-Type: application/json" \
-    -d '{}' \
-    "https://api.scaleway.com/functions/v1beta1/regions/fr-par/functions/<YOUR_FUNCTION_ID>/deploy"
-  ```
-
-  Your function is now being deployed.
-
-  <Message type="tip">
-    You can check the status of your function from the [Scaleway console](https://www.console/scaleway.com/) or by running the following command:
-
     ```json
-    curl -X GET \
+    curl -X POST \
       -H "X-Auth-Token: $SCW_SECRET_KEY" \
-      "https://api.scaleway.com/functions/v1beta1/regions/fr-par/functions/<YOUR_FUNCTION_ID>"
+      -H "Content-Type: application/json" \
+      -d '{}' \
+      "https://api.scaleway.com/functions/v1beta1/regions/fr-par/functions/<YOUR_FUNCTION_ID>/deploy"
     ```
-  </Message>
+
+    Your function is now being deployed.
+
+    <Message type="tip">
+      You can check the status of your function from the [Scaleway console](https://www.console/scaleway.com/) or by running the following command:
+
+      ```json
+      curl -X GET \
+        -H "X-Auth-Token: $SCW_SECRET_KEY" \
+        "https://api.scaleway.com/functions/v1beta1/regions/fr-par/functions/<YOUR_FUNCTION_ID>"
+      ```
+    </Message>
 
 6. Run the following command to call your function once it is deployed:
 
-```bash
-curl <YOUR_FUNCTION_ENDPOINT>
-```
+    ```
+    curl <YOUR_FUNCTION_ENDPOINT>
+    ```
diff --git a/serverless/functions/api-cli/deploy-function-cli.mdx b/serverless/functions/api-cli/deploy-function-cli.mdx
index b7d515cc4f..ee40b341d5 100644
--- a/serverless/functions/api-cli/deploy-function-cli.mdx
+++ b/serverless/functions/api-cli/deploy-function-cli.mdx
@@ -1,10 +1,10 @@
 ---
 meta:
   title: How to create and deploy a function with the Scaleway CLI
-  description: This page explains how to create and deploy a serverless function with the Scaleway CLI
+  description: This page explains how to create and deploy a Serverless Function with the Scaleway CLI
 content:
   h1: How to create and deploy a function with the Scaleway CLI
-  paragraph: This page explains how to create and deploy a serverless function with the Scaleway CLI
+  paragraph: This page explains how to create and deploy a Serverless Function with the Scaleway CLI
 tags: functions cli deploy
 dates:
   validation: 2023-08-18
@@ -48,7 +48,7 @@ categories:
     Do you want to override the current config? (Y/n):
     ```
 
-2. Type `n` and go directly to the [Creating a functions namespace](#creating-a-functions-namespace) step of this procedure if you do not want to edit your configuration.
+2. Type `n` and go directly to the [Creating a function](#creating-a-function) step of this procedure if you do not want to edit your configuration.
 
     If you have not yet configured the CLI, you will be guided through the configuration process via a series of questions:
 
@@ -88,86 +88,86 @@ categories:
 
 1. Run the following command in your terminal to create a functions namespace:
 
-  ```
-  scw function namespace create name=<YOUR_NAMESPACE_NAME>
-  ```
-
-  An output similar to the following displays:
-  
-  ```
-  ID                   6e74dbb7-9323-46bb-abc7-5c0105f4e70e
-  Name                 <YOUR_NAMESPACE_NAME>
-  OrganizationID       55e28409-776f-4f65-a41e-6c5fc58b4076
-  ProjectID            55e28409-776f-4f65-a41e-6c5fc58b4076
-  Status               pending
-  RegistryNamespaceID  -
-  RegistryEndpoint     -
-  Description          -
-  Region               fr-par
-  ```
-
-3. Run the following command in your terminal to create a function:
-
-  ```
-  scw function function create name=<FUNCTION_NAME> namespace-id=<NAMESPACE_ID> runtime=<YOUR_RUNTIME>
-  ```
+    ```
+    scw function namespace create name=<YOUR_NAMESPACE_NAME>
+    ```
 
     An output similar to the following displays:
-
-    ```
-    ID              717fb5f9-95c3-4c0b-84db-2321283e46dc
-    Name            <FUNCTION_NAME>
-    NamespaceID     cee31af8-d43e-4078-8f55-c921a9311f47
-    Status          created
-    MinScale        0
-    MaxScale        5
-    Runtime         python310
-    MemoryLimit     256
-    CPULimit        140
-    Timeout         5 minutes
-    Handler         handler.handle
-    Privacy         public
-    Description     -
-    DomainName      namespace0leshy-cli-fn-functionname.functions.fnc.fr-par.scw.cloud
-    Region          fr-par
-    HTTPOption      enabled
-    RuntimeMessage  -
-    ```
-
-  <Message type="tip">
-    Refer to [this page](/serverless/functions/reference-content/functions-lifecycle/#available-runtimes/) to see all the available runtimes
-  </Message>
-
-4. Create a zip file containing your function's code by following [this procedure](/serverless/functions/how-to/package-function-dependencies-in-zip/).
-
-  <Message type="note">
-    For testing purposes, you can create a zip archive with a simple Python file named `handler.py` inside, that contains the following code:
-
-    ```python
-    def handle(event, context):
-    return {
-        "body": {
-            "message": 'Hello, world',
-        },
-        "statusCode": 200,
-    }
-    ```
-  </Message>
+    
+    ```
+    ID                   6e74dbb7-9323-46bb-abc7-5c0105f4e70e
+    Name                 <YOUR_NAMESPACE_NAME>
+    OrganizationID       55e28409-776f-4f65-a41e-6c5fc58b4076
+    ProjectID            55e28409-776f-4f65-a41e-6c5fc58b4076
+    Status               pending
+    RegistryNamespaceID  -
+    RegistryEndpoint     -
+    Description          -
+    Region               fr-par
+    ```
+
+2. Run the following command in your terminal to create a function:
+
+    ```
+    scw function function create name=<FUNCTION_NAME> namespace-id=<NAMESPACE_ID> runtime=<YOUR_RUNTIME>
+    ```
+
+      An output similar to the following displays:
+
+      ```
+      ID              717fb5f9-95c3-4c0b-84db-2321283e46dc
+      Name            <FUNCTION_NAME>
+      NamespaceID     cee31af8-d43e-4078-8f55-c921a9311f47
+      Status          created
+      MinScale        0
+      MaxScale        5
+      Runtime         python310
+      MemoryLimit     256
+      CPULimit        140
+      Timeout         5 minutes
+      Handler         handler.handle
+      Privacy         public
+      Description     -
+      DomainName      namespace0leshy-cli-fn-functionname.functions.fnc.fr-par.scw.cloud
+      Region          fr-par
+      HTTPOption      enabled
+      RuntimeMessage  -
+      ```
+
+    <Message type="tip">
+      Refer to [this page](/serverless/functions/reference-content/functions-lifecycle/#available-runtimes/) to see all the available runtimes.
+    </Message>
+
+3. Create a zip file containing your function's code by following [this procedure](/serverless/functions/how-to/package-function-dependencies-in-zip/).
+
+    <Message type="note">
+      For testing purposes, you can create a zip archive with a simple Python file named `handler.py` inside, that contains the following code:
+
+      ```python
+      def handle(event, context):
+      return {
+          "body": {
+              "message": 'Hello, world',
+          },
+          "statusCode": 200,
+      }
+      ```
+    </Message>
 
 ## Deploying a function
 
 1. Run the following command to deploy your function with the zip archive you just created:
 
-```
-scw function deploy name=<FUNCTION_NAME> namespace-id=<NAMESPACE_ID> runtime=<YOUR_RUNTIME> zip-file=path/to/archive/<ZIP_FILE>
-```
+    ```
+    scw function deploy name=<FUNCTION_NAME> namespace-id=<NAMESPACE_ID> runtime=<YOUR_RUNTIME> zip-file=path/to/archive/<ZIP_FILE>
+    ```
 
-  The deployment process can take up to three minutes.
+    The deployment process can take up to three minutes.
 
 2. Run the following command to call your function:
 
-```bash
-curl <YOUR_FUNCTION_ENDPOINT>
-```
+    ```bash
+    curl <YOUR_FUNCTION_ENDPOINT>
+    ```
 
-  Your function is now deployed and ready to be used.
+    Your function is now deployed and ready to be used.