diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..49d2bdb4caa4e9b9dc140aee96748c4743269d8c
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,17 @@
+FROM public.ecr.aws/sam/build-provided
+
+#Installing rust
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rust-install.sh
+RUN sh rust-install.sh -y
+
+#Installing build dependencies
+# Zig is used for cross compilation to a lambda environment
+RUN curl https://ziglang.org/download/0.9.1/zig-linux-x86_64-0.9.1.tar.xz --output /tmp/zig-linux-x86_64-0.9.1.tar.xz
+RUN tar -xf /tmp/zig-linux-x86_64-0.9.1.tar.xz -C /usr/local \
+    && rm -f /tmp/zig-linux-x86_64-0.9.1.tar.xz \
+    && rm -rf zig-linux-x86_64-0.9.1
+
+#updating path
+ENV PATH="${PATH}:/root/.cargo/bin:/usr/local/zig-linux-x86_64-0.9.1"
+
+RUN cargo install cargo-lambda
\ No newline at end of file
diff --git a/README.md b/README.md
index ee02e8989d5ff97d11b63254a5162497e6f4510e..05d94af9fa70bc95f1a47f10eab46af89f6008da 100644
--- a/README.md
+++ b/README.md
@@ -1,92 +1,5 @@
 # rust-lambda-SAM
 
+Code source de mon article sur l'utilisation de Rust avec AWS Lambda.
 
-
-## Getting started
-
-To make it easy for you to get started with GitLab, here's a list of recommended next steps.
-
-Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!
-
-## Add your files
-
-- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files
-- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:
-
-```
-cd existing_repo
-git remote add origin https://gitlab.ippon.fr/llenoir/rust-lambda-sam.git
-git branch -M main
-git push -uf origin main
-```
-
-## Integrate with your tools
-
-- [ ] [Set up project integrations](https://gitlab.ippon.fr/llenoir/rust-lambda-sam/-/settings/integrations)
-
-## Collaborate with your team
-
-- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)
-- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)
-- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)
-- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)
-- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)
-
-## Test and Deploy
-
-Use the built-in continuous integration in GitLab.
-
-- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)
-- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)
-- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)
-- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)
-- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)
-
-***
-
-# Editing this README
-
-When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.
-
-## Suggestions for a good README
-Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.
-
-## Name
-Choose a self-explaining name for your project.
-
-## Description
-Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.
-
-## Badges
-On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.
-
-## Visuals
-Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.
-
-## Installation
-Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.
-
-## Usage
-Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.
-
-## Support
-Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.
-
-## Roadmap
-If you have ideas for releases in the future, it is a good idea to list them in the README.
-
-## Contributing
-State if you are open to contributions and what your requirements are for accepting them.
-
-For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.
-
-You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.
-
-## Authors and acknowledgment
-Show your appreciation to those who have contributed to the project.
-
-## License
-For open source projects, say how it is licensed.
-
-## Project status
-If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.
+N'hésitez pas à le lire ici : *A venir*
diff --git a/SamBasicRustApp/.gitignore b/SamBasicRustApp/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..e9138e13ee7b413183f84d4bc8af1cd6d6bc8074
--- /dev/null
+++ b/SamBasicRustApp/.gitignore
@@ -0,0 +1,3 @@
+.aws-sam/*
+
+*.lock
\ No newline at end of file
diff --git a/SamBasicRustApp/BasicRustFunction/Cargo.toml b/SamBasicRustApp/BasicRustFunction/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a43503424745091e317c89fec1f9cdb2d927c585
--- /dev/null
+++ b/SamBasicRustApp/BasicRustFunction/Cargo.toml
@@ -0,0 +1,9 @@
+[package]
+name = "basic-rust-function"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+lambda_runtime = "0.6.0"
+serde_json = "1.0.85"
+tokio = "1.21.0"
\ No newline at end of file
diff --git a/SamBasicRustApp/BasicRustFunction/Makefile b/SamBasicRustApp/BasicRustFunction/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..b90714eb12b7563b9985840dc17c804248ec3b3d
--- /dev/null
+++ b/SamBasicRustApp/BasicRustFunction/Makefile
@@ -0,0 +1,5 @@
+.PHONY: build
+
+build-BasicRustFunction:
+	cargo lambda build --release --target x86_64-unknown-linux-gnu.2.17
+	cp target/lambda/basic-rust-function/bootstrap ${ARTIFACTS_DIR}
\ No newline at end of file
diff --git a/SamBasicRustApp/BasicRustFunction/src/main.rs b/SamBasicRustApp/BasicRustFunction/src/main.rs
new file mode 100644
index 0000000000000000000000000000000000000000..bef413709f1657d9d1fce11fc02a8597eb5142e2
--- /dev/null
+++ b/SamBasicRustApp/BasicRustFunction/src/main.rs
@@ -0,0 +1,16 @@
+use lambda_runtime::{service_fn, Error, LambdaEvent};
+use serde_json::{json, Value};
+ 
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    let func = service_fn(func);
+    lambda_runtime::run(func).await?;
+    Ok(())
+}
+ 
+async fn func(event: LambdaEvent<Value>) -> Result<Value, Error> {
+    let (event, _context) = event.into_parts();
+    let first_name = event["firstName"].as_str().unwrap_or("world");
+ 
+    Ok(json!({ "message": format!("Hello, {}!", first_name) }))
+}
diff --git a/SamBasicRustApp/README.md b/SamBasicRustApp/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..af06777a1a5822ae6fc0db95bf64472024400c06
--- /dev/null
+++ b/SamBasicRustApp/README.md
@@ -0,0 +1,89 @@
+# sam-Rust-app
+
+This project contains source code and supporting files for a serverless application that you can deploy with the SAM CLI. It includes the following files and folders:
+
+- `Cargo.toml` - Project configuration file.
+- `src` - Code for the application's Lambda function.
+- `template.yaml` - A template that defines the application's AWS resources.
+
+The application uses several AWS resources, including Lambda functions and an API Gateway API. These resources are defined in the `template.yaml` file in this project. You can update the template to add AWS resources through the same deployment process that updates your application code.
+
+If you prefer to use an integrated development environment (IDE) to build and test your application, you can use the AWS Toolkit.  
+The AWS Toolkit is an open source plug-in for popular IDEs that uses the SAM CLI to build and deploy serverless applications on AWS. The AWS Toolkit also adds a simplified step-through debugging experience for Lambda function code. See the following links to get started.
+
+* [CLion](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [GoLand](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [IntelliJ](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [WebStorm](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [Rider](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [PhpStorm](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [PyCharm](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [RubyMine](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [DataGrip](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/welcome.html)
+* [VS Code](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/welcome.html)
+* [Visual Studio](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/welcome.html)
+
+## Deploy the sample application
+
+To deploy the application, you need the folllowing tools:
+
+* SAM CLI - [Install the SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html)
+* Docker - [Install Docker community edition](https://hub.docker.com/search/?type=edition&offering=community)
+* [Rust](https://www.rust-lang.org/) version 1.56.0 or newer
+* [cargo-lambda](https://github.com/cargo-lambda/cargo-lambda#installation) for cross-compilation
+
+To build and deploy your application for the first time, run the following in your shell:
+
+```bash
+make build
+sam deploy --guided
+```
+
+The first command will build the source of your application. The second command will package and deploy your application to AWS, with a series of prompts:
+
+* **Stack Name**: The name of the stack to deploy to CloudFormation. This should be unique to your account and region, and a good starting point would be something matching your project name.
+* **AWS Region**: The AWS region you want to deploy your app to.
+* **Confirm changes before deploy**: If set to yes, any change sets will be shown to you before execution for manual review. If set to no, the AWS SAM CLI will automatically deploy application changes.
+* **Allow SAM CLI IAM role creation**: Many AWS SAM templates, including this example, create AWS IAM roles required for the AWS Lambda function(s) included to access AWS services. By default, these are scoped down to minimum required permissions. To deploy an AWS CloudFormation stack which creates or modifies IAM roles, the `CAPABILITY_IAM` value for `capabilities` must be provided. If permission isn't provided through this prompt, to deploy this example you must explicitly pass `--capabilities CAPABILITY_IAM` to the `sam deploy` command.
+* **Save arguments to `samconfig.toml`**: If set to yes, your choices will be saved to a configuration file inside the project, so that in the future you can just re-run `sam deploy` without parameters to deploy changes to your application.
+
+You can find your API Gateway Endpoint URL in the output values displayed after deployment.
+
+
+## Add a resource to your application
+The application template uses AWS Serverless Application Model (AWS SAM) to define application resources. AWS SAM is an extension of AWS CloudFormation with a simpler syntax for configuring common serverless application resources such as functions, triggers, and APIs. For resources not included in [the SAM specification](https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md), you can use standard [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) resource types.
+
+## Fetch, tail, and filter Lambda function logs
+
+To simplify troubleshooting, SAM CLI has a command called `sam logs`. `sam logs` lets you fetch logs generated by your deployed Lambda function from the command line. In addition to printing the logs on the terminal, this command has several nifty features to help you quickly find the bug.
+
+`NOTE`: This command works for all AWS Lambda functions; not just the ones you deploy using SAM.
+
+```bash
+sam-Rust-app$ sam logs -n HelloWorldFunction --stack-name sam-Rust-app --tail
+```
+
+You can find more information and examples about filtering Lambda function logs in the [SAM CLI Documentation](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-logging.html).
+
+## Tests
+
+Tests are defined alongside your lambda function code in the `src` folder.
+
+```bash
+cargo test
+```
+
+
+## Cleanup
+
+To delete the sample application that you created, use the AWS CLI. Assuming you used your project name for the stack name, you can run the following:
+
+```bash
+sam delete
+```
+
+## Resources
+
+See the [AWS SAM developer guide](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) for an introduction to SAM specification, the SAM CLI, and serverless application concepts.
+
+Next, you can use AWS Serverless Application Repository to deploy ready-to-use apps that go beyond hello world samples and learn how authors developed their applications: [AWS Serverless Application Repository main page](https://aws.amazon.com/serverless/serverlessrepo/).
diff --git a/SamBasicRustApp/samconfig.toml b/SamBasicRustApp/samconfig.toml
new file mode 100644
index 0000000000000000000000000000000000000000..26dd207613b83170f2ead4e50c5a491a18c81b66
--- /dev/null
+++ b/SamBasicRustApp/samconfig.toml
@@ -0,0 +1,13 @@
+version = 0.1
+
+[default.build.parameters]
+build_image = ["BasicRustFunction=sam/build-rust-lambda"]
+[default.deploy]
+[default.deploy.parameters]
+stack_name = "sam-basic-rust-app"
+s3_bucket = "aws-sam-cli-managed-default-samclisourcebucket-nt2j7zmx313z"
+s3_prefix = "sam-basic-rust-app"
+region = "eu-west-1"
+confirm_changeset = true
+capabilities = "CAPABILITY_IAM"
+image_repositories = []
diff --git a/SamBasicRustApp/template.yaml b/SamBasicRustApp/template.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..759d3c8172d80dc7152495acd2fd830e920acc09
--- /dev/null
+++ b/SamBasicRustApp/template.yaml
@@ -0,0 +1,22 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+Description: >
+  sam-basic-Rust-app
+
+  Sample SAM Template for building the most basic Rust Function possible 
+
+Resources:
+
+  BasicRustFunction:
+    Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
+    Properties:
+      CodeUri: ./BasicRustFunction
+      Handler: bootstrap.is.the.handler # the handler for a binary does not matter
+      Runtime: provided
+    Metadata:
+      BuildMethod: makefile
+
+Outputs:
+  BasicRustFunctionFunction:
+    Description: "Basic Rust Function ARN"
+    Value: !GetAtt BasicRustFunction.Arn
\ No newline at end of file