## Nest.js 

[Nest.js](https://nestjs.com) est un framework pour construire des applications JavaScript et TypeScript côté serveur. Il fournit une abstraction au dessus d'Express.js ou de Fastify. Il a une bonne architecture et des applications côté serveur plus importantes peuvent être programmées plus rapidement qu'avec Express.js ou Fastify. Souvent, les applications Nest.js utilisent un ORM (Object-Relational Mapping) et c'est ainsi que Prisma entre en jeu. 

## Prisma 

L'utilisation d'un ORM dans une application Node et Nest.js facilite la manipulation et l'interrogation de données dans une base de données SQL. En raison du décalage entre un langage de programmation orienté objet comme TypeScript et le modèle de données relationnel, un outil comme Prisma est très utile. Prisma a une seule source de vérité pour le modèle de données, ce qui est une bonne conception. Il peut facilement être utilisé dans une application Nest.js. Une fois que vous avez développé votre application Nest.js, vous devez également penser au déploiement. C'est là que les conteneurs avec Docker brillent. 

## Docker

[Docker](https://www.docker.com) est utilisé pour automatiser le déploiement de logiciels dans des paquets légers appelés conteneurs. C'est aujourd'hui la norme pour le déploiement de logiciels côté serveur dans le nuage. Ainsi, lorsque vous souhaitez déployer votre application Nest.js qui utilise Prisma vers un service de nuage qui prend en charge Docker, vous devez écrire un *Dockerfile*. Le Dockerfile spécifie les étapes de création d'une image Docker. 

## Comment Dockeriser 

Voici un exemple de Dockerfile pour une application Nest.js qui utilise Prisma : 

```Docker
# Utiliser un runtime Node.js officiel comme image de base # Cette ligne spécifie l'image de base pour l'image Docker. Dans ce cas, nous utilisons une image officielle du runtime Node.js avec la version 18.18 et la 
# distribution Linux Alpine. 
FROM node:18.18-alpine 

# Cette ligne définit le répertoire de travail à l'intérieur du conteneur à /usr/src/app. C'est là que nous copierons le code de notre # application et que celle-ci s'exécutera. 
WORKDIR /usr/src/app 

# Cette ligne installe le paquet build-base en utilisant le gestionnaire de paquets Alpine (apk). Ce paquet comprend les outils nécessaires pour 
# construire des modules Node.js natifs. 
RUN apk add build-base 

# Cette ligne installe Python 3 en utilisant le gestionnaire de paquets Alpine. Python est nécessaire pour certains modules Node.js qui ont des dépendances natives. 
RUN apk add python3 

# Cette ligne installe le paquet node-gyp globalement en utilisant npm. node-gyp est un outil pour construire des modules Node.js 
# natifs. 
RUN npm install -g node-gyp 

# Copier package.json et package-lock.json dans le conteneur 
COPY package*.json ./ 

# Installer les dépendances de l'application 
RUN npm install 

# Copier le reste du code de votre application dans le conteneur 
COPY . . 

# Cette ligne définit une variable d'environnement qui indique à Prisma ORM d'ignorer les sommes de contrôle manquantes du moteur. Ceci est utile lors du déploiement sur certaines 
# plateformes comme Heroku. 
ENV PRISMA_ENGINES_CHECKSUM_IGNORE_MISSING=1 

# Cette ligne génère le code client Prisma basé sur le schéma défini dans l'application. 
RUN npx prisma generate 

# Expose le port sur lequel votre application s'exécutera (Nest.js par défaut est 3000) 
EXPOSE 3000 

# Définit la commande pour exécuter votre application 
CMD ["npm", "start"] 
```

J'ai inclus des commentaires à chaque ligne du *Dockerfile*. Veuillez noter qu'à cause de Prisma, il y a eu plus d'étapes nécessaires que pour une application Nest.js pure. Dans ce *Dockerfile*, j'ai utilisé une image Alpine Linux Node parce qu'elle est plus petite en taille et plus sûre que l'image Node standard. L'étape suivante est de construire l'image en utilisant Docker. Vous pouvez le faire avec la commande suivante : 

```bash docker build -t <image-name> . ``` 

Ensuite, vous pouvez démarrer l'image et l'exécuter en tant que conteneur. Si vous utilisez un outil comme Docker Desktop, il suffit de cliquer sur le bouton run. Il existe également une commande en ligne de commande : 

``bash docker run -p <host-port>:<container-port> <image-name> `` 

Dans notre cas, le *container-port* est 3000 (commande EXPOSE 3000 dans le Dockerfile). 

Enfin, vous devriez pouvoir accéder à votre application déployée. 

## Conclusion 

Comme vous avez pu le constater, les applications Nest.js ne sont pas difficiles à dockeriser. Lorsque vous utilisez le client Prisma, il y a un certain nombre d'étapes supplémentaires à suivre. J'espère que vous avez appris quelque chose de nouveau. 

## Références 

- Nest.js : [https://nestjs.com](https://nestjs.com) 
- Prisma : [https://www.prisma.io](https://www.prisma.io) 
- Docker : [https://www.docker.com](https://www.docker.com) 

Photo de couverture : <a href="https://unsplash.com/de/@lazycreekimages?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Michael Dziedzic</a> sur <a href="https://unsplash.com/de/fotos/dreieckiges-rotes-und-blaues-dreieck-W6l35A_rxxU?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Unsplash</a>

large_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

medium_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

small_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

thumbnail_michael-dziedzic-W6l35A_rxxU-unsplash.jpg

Souvent, les gens utilisent Nest.js et Prisma ensemble lorsqu'ils programment une application backend. La question se pose alors de savoir comment déployer l'application avec Docker. Cet article vous montre comment faire. 


Comment dockeriser une application Prisma Nest.js

Lorsque vous utilisez [GitLab](https://gitlab.com/) pour héberger le code source de votre projet de développement de logiciel web, vous pouvez déployer votre site web vers [Cloudflare Pages](https://pages.cloudflare.com/).
Normalement, vous devriez utiliser le pipeline GitLab CI pour construire votre projet de site Web. Dans cet article, je vous montre donc comment configurer votre GitLab CI pour qu'il se déploie sur les pages Cloudflare.

## GitLab

GitLab est une plateforme d'hébergement et de DevOps partiellement open source basée sur Git, dont les racines remontent à l'Ukraine. Avec son siège social à San Francisco, elle propose le suivi des problèmes, l'intégration continue et un pipeline de déploiement. Étant donné que GitLab ne propose pas de fonctionnalités cloud avancées comme l'hébergement de sites statiques ou de fonctions serverless, vous pouvez combiner GitLab avec des offres tierces, par exemple de la société Cloudflare.

## Pages Cloudflare

[Cloudflare](https://www.cloudflare.com/) est une société d'hébergement en nuage qui propose un CDN et d'autres services aux créateurs de sites web.
Cloudflare Pages est l'offre de Cloudflare orientée vers les développeurs frontaux qui veulent déployer rapidement leur site Web. Vous pouvez le connecter directement à GitLab, mais vous devez autoriser Cloudflare à accéder à votre dépôt GitLab.
Si vous ne souhaitez pas autoriser Cloudflare à accéder à votre dépôt Git, vous pouvez déployer le code directement à partir de votre pipeline GitLab CI.

## Configuration du pipeline GitLab CI

L'exécution d'un pipeline de CI est une bonne pratique pour tout projet de logiciel web. Un pipeline de CI est une série
d'étapes qui doivent être exécutées pour livrer une nouvelle version d'un logiciel.

Dans GitLab, il existe le `.gitlab-ci.yml` où vous configurez vos étapes de construction et de déploiement.
Le fichier `.gitlab-ci.yml` est un fichier [Yaml](https://yaml.org/) qui contient ces commandes. Les commandes sont exécutées dans l'ordre où elles sont listées.
Il comprend une définition des
variables qui sont nécessaires pour le déploiement sur les pages Cloudflare. Ces variables sont appelées `$CLOUDFLARE_API_TOKEN` et `$CLOUDFLARE_ACCOUNT_ID`.
Ils sont transmis à la [wrangler](https://developers.cloudflare.com/workers/wrangler/) CLI de Cloudflare et sont nécessaires pour activer l'authentification. Le programme `wrangler` est une interface de ligne de commande (CLI) pour l'API Cloudflare. Il est utilisé ici pour déployer le code frontal sur le serveur de pages
serveur Cloudflare Pages.

Afin de protéger ces jetons d'accès, ils doivent être définis directement dans les paramètres de GitLab, sous la rubrique `CI/CD`. Là, vous devez
de développer le `Variables` et ajoutez les valeurs. Elles seront ensuite remplies lors de l'exécution du pipeline CI.

Dans l'application Web Cloudflare, sous `My Profile/API Token` vous pouvez générer ces jetons d'API. Vous devez créer un token qui a au minimum les droits de
pour modifier les pages Cloudflare (`Cloudflare Pages:Edit`) et de lire l'adhésion (`Memberships:Read`).

Vous pouvez ensuite créer le script de déploiement CI dans votre projet GitLab.

Vous pouvez utiliser ce script comme exemple :

.gitlab-ci.yml

```yaml
image: node:16.13

cache:
  paths:
    - node_modules/
    - .cache/
    - public/

pages:
  variables:
    CLOUDFLARE_API_TOKEN: $CLOUDFLARE_API_TOKEN
    CLOUDFLARE_ACCOUNT_ID: $CLOUDFLARE_ACCOUNT_ID
  stage: deploy
  script:
    - npm install
    - ./node_modules/.bin/gatsby build
    - npm install -g wrangler --unsafe-perm=true
    - wrangler pages publish ./public --project-name=your-website --branch=main
  artifacts:
    paths:
      - public
  only:
    - master
```

Ce script génère de manière statique un site Web JavaScript statique à l'aide de Gatsby et le déploie sur les pages Cloudflare à l'aide de la fonction `wrangler`.
Pour que ce script fonctionne dans votre projet, vous devez personnaliser les valeurs passées à la commande `wranger` notamment le `--project-name`. Il s'agit du nom que vous avez choisi lors de la création du projet Cloudflare Pages.
En outre, vous devrez peut-être adapter le nom du dossier où se trouve le code frontal généré qui doit être déployé. Dans l'exemple ci-dessus, il s'agit de `./public`.

## Conclusion

J'espère que cet article vous aura appris que l'intégration d'un déploiement vers les pages Cloudflare à partir du CI GitLab n'est pas
pas très compliqué. Une approche similaire peut être utilisée pour d'autres applications de construction CI.

## Références

- GitLab : [https://gitlab.com](https://gitlab.com)

- Cloudflare Pages : [https://pages.cloudflare.com](https://pages.cloudflare.com)

- Cloudflare Wrangler : [https://developers.cloudflare.com/workers/wrangler](https://developers.cloudflare.com/workers/wrangler)


large_cover.png

medium_cover.png

small_cover.png

thumbnail_cover.png

Lorsque vous utilisez GitLab pour héberger le code source de votre projet de développement de logiciel Web, vous pouvez déployer votre site Web sur les pages Cloudflare. Normalement, vous utilisez le pipeline GitLab CI pour construire votre projet de site Web. Dans cet article, je vous montre donc comment configurer votre GitLab CI pour qu'il se déploie sur les pages Cloudflare.

Comment déployer des pages GitLab vers Cloudflare?

Les fonctions Netlify sont des codes sans serveur qui sont faciles à déployer. Ici, je veux montrer comment programmer une simple fonction Netlify pour envoyer un message de contact depuis mon site web à une adresse e-mail et l'enregistrer dans une feuille Airtable.
Dans les coulisses, Netlify utilise les fonctions AWS Lambda et gère toutes les tâches complexes comme la configuration d'une passerelle API, etc.

## Netlify

[Netlify](https://www.netlify.com/) est une entreprise basée à San Francisco qui propose l'hébergement de sites statiques et de fonctions serverless. Elle a été fondée en 2014 et dispose d'une quantité généreuse de fonctions serverless gratuites.
L'entreprise se concentre sur le cas d'utilisation Jamstack, qui est un mouvement évolutif visant à utiliser les sites statiques et le
code sans serveur pour fournir des sites web plus simples, plus rapides et plus sûrs.

## Sendgrid

Le service que j'utilise ici pour envoyer le message de contact à mon adresse email est Sendgrid de Twilio.

[Twilio](https://www.twilio.com/) est une société de communication en ligne basée à San Francisco qui offre des API de messagerie en nuage.
 Vous pouvez envoyer un certain nombre d'e-mails gratuitement par mois avec le plan gratuit.


## Airtable

[Airtable](https://airtable.com/) est également basé à San Francisco et est un fournisseur d'une plate-forme de communication avec une API.
Pour notre but, vous devez créer une base que nous utilisons pour enregistrer la demande de contact depuis notre site web.
Vous devez ajouter les quatre champs ("Name", "Email", "Message" et "Date").

Plus tard, quand un utilisateur envoie un message, les données seront enregistrées dans la base Airtable
et vous pourrez les consulter.

## Préparation

Pour un déploiement simple, Netlify offre une ligne de commande appelé Netlify CLI. Vous pouvez l'installer via :

```bash
npm install netlify-cli -g
```

Pour plus d'informations sur la configuration de Netlify CLI et la connexion à votre compte, consultez la page de documentation :

https://docs.netlify.com/cli/get-started/

## Le package.json

Le projet TypeScript du formulaire de contact utilise les paquets tiers suivants :

```Json
{
  "name": "contact-form",
  "version": "1.0.0",
  "description": "Netlify function for contact form messaging",
  "main": "contact-form.ts",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "netlify",
    "serverless",
    "typescript"
  ],
  "author": "Netlify",
  "license": "MIT",
  "dependencies": {
    "@netlify/functions": "^0.7.2",
    "@sendgrid/mail": "^7.4.7",
    "airtable": "^0.11.1",
    "typescript": "^4.0.0"
  },
  "devDependencies": {
    "@types/node": "^16.9.6"
  }
}
```

Les deux paquets pour l'intégration de Sendgrid et de Airtable sont inclus dans ce fichier.

## La fonction de contact

La fonction de contact est écrite en TypeScript et ressemble à ceci :

```typescript
import { Handler } from "@netlify/functions";
import sendgridMail from "@sendgrid/mail";
import Airtable from 'airtable';

sendgridMail.setApiKey(process.env.SENDGRID_API_KEY);

Airtable.configure({ apiKey: process.env.AIRTABLE_API_KEY })
const base = Airtable.base('app1x2RVWTmxkxcxx');

export const handler: Handler = async (event) => {
  const { email, name, message } = event.queryStringParameters;
  const date = new Date();

  base('Table 1').create([
    {
      "fields": {
        Name: name,
        Email: email,
        Message: message,
        Date: `${date.getMonth()+1}/${date.getDate()}/${date.getFullYear()}`,
      }
    },
  ], (err) => {
    if (err) {
      console.error(err);
    } else {
      console.log("Successfully logged to Airtable!");
    }
  });

  const msg = {
    to: "youraddress@mail.com",
    from: "youremail@website.com",
    subject: "Contact Message from Website",
    text: `Message from ${name} with email ${email}: ${message}`,
    html: `Message from ${name} with email ${email}: ${message}`,
  };

  try {
    await sendgridMail.send(msg);
  } catch (error) {
    console.error(error);

    if (error.response) {
      console.error(error.response.body);

      return {
        statusCode: 400,
        headers: {
          'Access-Control-Allow-Origin': '*', // Required for CORS support to work
        },
        body: JSON.stringify({
          message: 'Error: '+JSON.stringify(error.response.body)
        }),
      };
    }
  }

  return {
    statusCode: 200,
    headers: {
      'Access-Control-Allow-Origin': '*', // Required for CORS support to work
    },
    body: JSON.stringify({
      message: 'Success!'
    }),
  };
};
```

Avant de pouvoir exécuter la fonction localement, vous devez définir les variables d'environnement. Sur les systèmes basés sur Linux, vous pouvez simplement exécuter ``export SENDGRID_API_KEY=votre-clé`` dans le terminal.
De même pour la variable ``AIRTABLE_API_KEY``.

De plus, vous devez adapter la variable Airtable dans le code avec votre propre ID et adapter le nom de la table ("Table 1") s'il est différent.

De plus, pour recevoir le message électronique, vous devez entrer votre adresse électronique dans la propriété '''msg.to'''. adresse électronique dans la propriété '''msg.to'''.

## Test de la fonction

Vous pouvez exécuter et tester la fonction localement avec la commande suivante :

```
netlify dev
```

Vous pouvez tester la fonction GET http dans votre navigateur Web ou à l'aide d'un outil comme [Insomnia](https://insomnia.rest/) en allant à l'adresse vers :

```
http://localhost:8888/.netlify/functions/contact-form/?name=Wolf&email=test@wolf.com&message=Hi!
```

Si cela a réussi, vous devriez recevoir un email et les paramètres devraient être enregistrés dans votre base Airtable.


## Déploiement en production

Maintenant si tout a bien fonctionné vous pouvez déployer votre fonction en production avec une simple commande :

```
netlify deploy --prod
```

Vous obtenez également un point de terminaison sécurisé https après le déploiement. Ce point de terminaison sécurisé que vous pouvez utiliser dans votre code frontal pour appeler la fonction.

Sachez que vous devez définir vos variables d'environnement dans l'application web de Netlify où vous avez configuré et paramétré votre fonction.


## Conclusion

Les fonctions Netlify constituent un moyen simple de programmer et de déployer des fonctions lambda AWS. Elles s'intègrent bien aux API tierces, grâce à l'outil CLI, vous pouvez facilement les tester localement, ce qui accélère le développement.

## Références

- Fonctions Netlify : [https://docs.netlify.com/functions/overview](https://docs.netlify.com/functions/overview)

- Twilio Sendgrid : [https://www.twilio.com/sendgrid](https://www.twilio.com/sendgrid)

- Airtable : [https://airtable.com](https://airtable.com)

- Insomnia API client : [https://insomnia.rest](https://insomnia.rest)

large_cover.jpg

medium_cover.jpg

small_cover.jpg

thumbnail_cover.jpg

Les fonctions Netlify sont des codes sans serveur qui sont faciles à déployer. Ici, je veux montrer comment programmer une simple fonction Netlify pour envoyer un message de contact depuis mon site web à une adresse email et l'enregistrer dans une feuille Airtable.

Fonctions Netlify simples pour la messagerie de contact

[Serverless](https://serverless.com/) est un framework permettant de construire et déployer du code sans serveur. Approvisionnement et la mise à l'échelle est automatiquement prise en charge par le fournisseur de cloud computing. Le framework Serverless est une abstraction au-dessus des plus importants fournisseurs de cloud. Ce tutoriel montrera comment écrire une fonction qui vous envoie un courriel avec les coordonnées du client. C'est un cas d'utilisation populaire pour les formulaires de contact sur les sites Web.

Pour les besoins de ce tutoriel, l'API [Twilio Sendgrid API](https://github.com/sendgrid/sendgrid-nodejs/tree/master/packages/mail) sera utilisée pour envoyer un e-mail.
Ce tutoriel nécessite une connaissance de base de JavaScript et des appels API.

## Serverless Computing

[Serverless computing](https://en.wikipedia.org/wiki/Serverless_computing), également connu sous le nom de function as a service (FaaS), a d'abord été mis au point par la société Amazon AWS avec AWS Lambda en 2014. Malgré son nom qui implique une utilisation sans serveur, des serveurs sont tout de même impliqués.
Mais le développeur n'a pas besoin de prendre soin de ces serveurs. Elle peut écrire le code du serveur
puis exécutez une commande pour déployer automatiquement la fonction. La mise à l'échelle est prise en charge
par le fournisseur de cloud. Souvent, le prix est basé sur le nombre d'appel de la fonction et la mémoire ou le temps CPU.

Cela signifie que les coûts de serveur fixes qui étaient traditionnellement
calculé en fonction de la durée d'exécution du serveur sont maintenant devenus des coûts variables en fonction du nombre d'appels et de la mémoire ou du CPU.

Les nouveaux cas d'utilisation pour l'informatique sans serveur sont par exemple le redimensionnement d'une image après téléchargement ou envoyer un e-mail au service après-vente lorsque le client saisit ses informations de contact et écrit un message sur un formulaire de contact du site web.

Ce tutoriel décrit ce dernier cas d'utilisation. D'autres cas d'utilisation incluent le streaming d'événements par exemple, ou bien d'autres utilisations qui sont énumérés sur le [site Web de Serverless](https://serverless.com/learn/use-cases/).

## Framework Serverless

Le [framework Serverless](https://serverless.com/) est un framework libre et open source écrite en Node.js.
Il prend en charge tous les principaux fournisseurs de cloud comme [AWS](https://aws.amazon.com/), [Google Cloud](https://cloud.google.com/), [Azure](https://azure.microsoft.com/en-us/), [CloudFlare Workers](https://www.cloudflare.com/de-de/products/cloudflare-workers/) et [Alibaba Cloud](https://us.alibabacloud.com/). Il existe également une version d'entreprise que l'entreprise à l'origine de l'initiative du framework Serverless, Serverless Inc. supporte.
Serverless Inc., est une start-up basée à San Francisco, USA et qui a notamment le soutien de [Trinity Ventures](https://www.trinityventures.com), entre autres.

L'installation de Serverless est assez simple. Suivez les instructions de la page [Documents Serverless](https://serverless.com/framework/docs/getting-started/).

Ensuite, clonez l'exemple d'application [serverless-message exemple d'application](https://github.com/tderflinger/serverless-message) depuis le répertoire GitHub.
Exécutez _npm install_ et ceci résout les dépendances du paquet.

## Configuration

Toute la configuration majeure se fait dans le fichier _serverless.yml_.
Vous y trouverez des informations sur le fournisseur de cloud à utiliser,
quelle durée d'exécution et quelle région.

Sous _functions_, le nom de la fonction est spécifié,
sa méthode http (POST) et que CORS devrait être activés. Aussi, il s'agit d'une fonction privée, ce qui signifie que l'appelant doit inclure
la clé API dans l'en-tête de l'appel POST. La valeur de la clé API se trouve dans la section _apiKeys_.

serverless.yml

```yml
service: serverless-message

provider:
  name: aws
  runtime: nodejs8.10
  region: eu-central-1
  apiKeys:
    - name: firstKey
      value: JNJSNKMKDMKSMKMDKMDK
  environment:
    SENDGRID_API_KEY: Your API Key
    MESSAGE_TO: Your email address
    MESSAGE_FROM: The sender email address (your website domain)
  usagePlan:
    quota:
      limit: 5000
      offset: 2
      period: MONTH
    throttle:
      burstLimit: 20
      rateLimit: 10

functions:
  sendMessage:
    handler: handler.sendMessage
    events:
      - http:
          path: send-message
          method: post
          cors: true
          private: true

plugins:
  - serverless-offline
```

Il y a également trois variables que vous devez définir.
La clé `SENDGRID_API_KEY` est votre clé API Sendgrid. Il peut être créé après l'inscription à [Twilio Sendgrid](https://www.twilio.com/sendgrid).

Les deux autres variables d'environnement sont l'adresse de courriel à laquelle le fichier message de contact du client doit être envoyé. C'est normalement votre adresse e-mail professionnelle. Vous y recevrez le message lorsque qu'un client soumet une demande de contact sur votre site Web. La variable `MESSAGE_FROM` est l'adresse e-mail de votre site web.

L'autre section est le _usagePlan_ qui est un élément de sécurité où vous pouvez définir le nombre maximum d'invocations mensuelles.

## Fonction Serverless

C'est le cœur de l'application. La fonction de gestionnaire n'est qu'une fonction JavaScript normale. Vous pouvez importer du code à partir des paquets Node. Dans ce cas, le _@sendgrid/mail_ est nécessaire pour envoyer l'e-mail.

Sinon, la fonction est simple. Elle envoie un e-mail avec les données (nom, courriel, message) qui ont été inclues dans le corps de l'appel POST.

Le front-end devra ensuite enregistrer les données à partir des informations saisies par le client dans le formulaire. Actuellement, le front-end ne fait pas partie de cette application.

handler.js

```javascript
'use strict'

const sgMail = require('@sendgrid/mail')

function sendEmail(data) {
  sgMail.setApiKey(process.env.SENDGRID_API_KEY)
  const msg = {
    to: process.env.MESSAGE_TO,
    from: process.env.MESSAGE_FROM,
    subject: 'New Message from Website',
    text: `Message from ${data.name} - ${data.email}: ${data.message}`,
    html: `<strong>Message from ${data.name} - ${data.email}: ${
      data.message
    }</strong>`,
  }
  sgMail.send(msg)
}

module.exports.sendMessage = (event, context, callback) => {
  const data = JSON.parse(event.body)
  sendEmail(data)

  const response = {
    statusCode: 201,
    headers: {
      'Access-Control-Allow-Origin': '*', // Required for CORS support to work
    },
    body: JSON.stringify({
      message: 'Message sent successfully.',
      input: event,
    }),
  }

  callback(null, response)
}
```

La fonction renvoie un code de succès 201 avec un message de confirmation.

## Test hors ligne

L'avantage de Serverless est qu'il possède un bon écosystème de plugins.
Il y a aussi un plugin très utile pour tester la fonction AWS serverless localement sur votre PC. Ce plugin s'appelle [serverless-offline](https://github.com/dherault/serverless-offline).

Vous pouvez exécuter la fonction localement avec :

```bash
sls offline
```

Cela démarre un serveur local et imprime également la clé API. Vous pouvez par exemple utiliser [Postman](https://www.getpostman.com/) pour exécuter une commande POST contre le serveur. Vous devez inclure pour cela la clé API dans le header (x-api-key).

Voici un exemple de corps de message POST :

```json
{
  "email": "superman@superduppa8.com",
  "name": "Superman",
  "message": "Greetings to Nietzsche!"
}
```

Dans ce cas, un e-mail contenant ces informations vous sera envoyé à l'adresse e-mail que vous avez configurée.

## Déployer

Le déploiement est facile, mais peut prendre un peu de temps, car toutes les ressources doivent être
téléchargées et fournies.

Exécutez la commande :

```bash
sls deploy
```

Veuillez noter que vous avez besoin d'un CLI AWS fonctionnel installé localement et l'utilisateur AWS doit avoir les droits corrects pour installer les fonctions lambda AWS.
Reportez-vous à la [documentation sur la CLI](https://docs.aws.amazon.com/fr_fr/cli/index.html) et aux tutoriels sur Serverless énumérés ci-dessous.

## Conclusion

Serverless simplifie grandement le développement des fonctions sans serveur.
De plus, il vous permet de changer relativement facilement de fournisseur de cloud, évitant ainsi le verrouillage du fournisseur.
En tant que cadre open source, il dispose d'un vaste écosystème, est populaire et a le soutien d'une société commerciale.

## Sources et lectures complémentaires

- Serverless : [https://serverless.com](https://serverless.com)

- Serverless Offline : [https://github.com/dherault/serverless-offline](https://github.com/dherault/serverless-offline)

- Twilio Sendgrid : [https://www.twilio.com/sendgrid](https://www.twilio.com/sendgrid)

- Tutorials as introduction to Serverless : [https://hackernoon.com/best-tutorials-to-get-started-with-serverless-97c86623cdc0](https://hackernoon.com/best-tutorials-to-get-started-with-serverless-97c86623cdc0)

- serverless-message example application : [https://github.com/tderflinger/serverless-message](https://github.com/tderflinger/serverless-message)


large_serverless.jpg

medium_serverless.jpg

small_serverless.jpg

thumbnail_serverless.jpg

Serverless est un framework permettant de construire et déployer du code sans serveur. Le provisionnement et la mise à l'échelle sont automatiquement pris en charge par le fournisseur de cloud computing. Le framework Serverless est une abstraction au-dessus des fournisseurs de cloud les plus importants. Ce tutoriel montrera comment écrire une fonction qui envoie un email avec des informations de contact. C'est un cas d'utilisation populaire pour les formulaires de contact sur les sites Web.

Serverless pour les messages de contact

Dans la première partie de la série DevOps, j'ai montré comment créer automatiquement une instance AWS EC2 Spot avec Terraform.
Vous pouvez le relire ici : https://www.tderflinger.com/fr/ec2-spot-avec-terraform

Les compétences de DevOps deviennent de plus en plus importantes pour les développeurs de Node.js. Avec Ansible, vous pouvez configurer automatiquement vos serveurs cloud.
Maintenant, je vous explique comment configurer automatiquement le serveur CentOS créé avec Node.js et Nginx. Pour ce, j'utilise l'outil open source [Ansible](https://www.ansible.com/). Ansible est un outil de configuration et de déploiement logiciel. Il a été écrit à l'origine par Michael DeHaan en 2012. L'entreprise à l'origine d'Ansible a été acquise en 2015 par Red Hat, aujourd'hui une division d'IBM.

Ansible vous permet d'automatiser l'installation des logiciels. Il s'agit donc d'un élément important dans l'[Infrastructure as Code (IaC)](https://fr.wikipedia.org/wiki/Infrastructure_as_Code).
Avec Ansible, vous pouvez vous assurer que les bons paquets sont installés, que les bons fichiers de configuration sont à la bonne place et que les bons services fonctionnent. Vous pouvez également déployer votre logiciel écrit sur le serveur avec Ansible.
De plus, Ansible permet de provisionner un nouveau serveur, mais j'ai utilisé Terraform pour cette tâche comme vous pouvez le lire dans l'article précédent.

Ansible est un bon outil pour les environnements de cloud computing de type [IaaS (Infrastructure as a Service)](https://fr.wikipedia.org/wiki/Infrastructure_as_a_service). Cela inclut les serveurs AWS EC2 ou les droplets de Digital Ocean. Sur ce type de serveurs de calcul vous devez configurer vous-même le logiciel nécessaire. Cela contraste avec les offres [PaaS](https://fr.wikipedia.org/wiki/Plate-forme_en_tant_que_service), où tout est géré, vous téléchargez uniquement le code source de votre application. Heroku est un exemple d'offre PaaS.

Lorsque vous utilisez Ansible, vous ferez la plupart de votre travail dans des fichiers de configuration appelés playbooks. Ce sont des [fichiers yml](https://fr.wikipedia.org/wiki/YAML) qui sont DSL (Domain Specific Languages) et décrivent les fonctions à configurer.

L'avantage d'Ansible est que vous n'avez pas besoin d'installer plus sur le serveur cible. Tout fonctionne avec le port 22, via SSH. Seul Python 2 ou 3 doit être disponible sur la machine cible. Ceci distingue Ansible des outils comme Chef ou Puppet où vous devez installer un agent.

## Serveur Mock

Pour cet exemple, je veux installer automatiquement un serveur mock Node.js à des fins de test. Pour cela j'utilise le [module NPM json-server](https://www.npmjs.com/package/json-server) et j'ajoute un peu de code maquette. Fondamentalement, le serveur mock est un serveur REST avec des données fantaisie.

json-server-http.js

```javascript
var fs = require('fs'),
  jsonServer = require('json-server'),
  server = jsonServer.create(),
  router = jsonServer.router('db.json'),
  middlewares = jsonServer.defaults()
const cors = require('cors')
const bodyParser = require('body-parser')

server.use(cors())
server.use(bodyParser.json())

server.use(middlewares)
server.use(router)

server.listen(3002, function() {
  console.log('json-server started on port ' + 3002)
})
```

Il charge certaines données à partir d'un fichier JSON et renvoie les données via le terminal REST.

L'une des conditions requises pour ce serveur mock est qu'il soit disponible via HTTPS. Ainsi, j'utilise le serveur Nginx comme proxy avec une connexion TLS. Les fichiers de certificats et de clés nécessaires peuvent être générés hors ligne avec cet Ansible Playbook.

## Générer un certificat TLS

Vous devez d'abord [installer Ansible](https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html_guide/intro_installation.html) sur votre ordinateur.

Le playbook Ansible suivant génère sur votre ordinateur local le certificat auto-signé et les fichiers de clés privées. Ces fichiers sont
plus tard téléchargés dans les répertoires Nginx.

generate_certificate.yml

```yml
--
- name: Generate Nginx TLS certificates and keys
  hosts: localhost

  tasks:
    - name: Generate OpenSSL private key
      openssl_privatekey: path=files/nginx.key

    - name: Generate OpenSSL Certificate Signing Request
      openssl_csr: path=files/csr.csr  privatekey_path=files/nginx.key common_name=www.someorg.org

    - name: Generate Self-signed certificate
      openssl_certificate: path=files/nginx.crt privatekey_path=files/nginx.key csr_path=files/csr.csr provider=selfsigned
```

Vous pouvez exécuter ce playbook avec la commande suivante:

```bash
ansible-playbook generate_certificate.yml
```

## Installer Node.js et Nginx

Le travail de configuration proprement dit s'effectue avec l'installation du logiciel requis. Premièrement, Node.js est nécessaire dans la version 10.16. Une bonne façon d'installer Node.js sur un serveur Linux est d'utiliser le [Node Version Manager (NVM)](https://github.com/nvm-sh/nvm).
Sur GitHub il y a un [playbook Ansible prêt à l'emploi](https://github.com/morgangraphics/ansible-role-nvm) pour installer NVM. Nous l'utilisons ici et l'invoquons simplement dans notre script.

Ensuite, Nginx doit être installé. Le livre de jeu ressemble à ceci :

install_nodenginx.yml

```yml
---
- name: Install curl and wget
  gather_facts: 'no'
  hosts: mock
  become: yes
  remote_user: root

  tasks:
    - name: Install curl
      yum:
        name: curl
        state: present

    - name: Install wget
      yum:
        name: wget
        state: present

- name: Create nvm
  gather_facts: 'no'
  hosts: mock
  become: yes
  remote_user: root

  roles:
    - role: ansible-role-nvm
      nodejs_version: '10.16.0'

## Credits to John Lieske - https://www.ansible.com/blog/getting-started-writing-your-first-playbook
- name: Install Nginx
  hosts: mock
  become: yes
  remote_user: root

  tasks:
    - name: Add epel-release repo
      yum:
        name: epel-release
        state: present

    - name: Install Nginx
      yum:
        name: nginx
        state: present

    - name: Start NGiNX
      service:
        name: nginx
        state: started
```

Avant d'exécuter ce playbook, vous devez également spécifier votre fichier hosts.

Il peut ressembler à ceci, mais vous devez mettre à jour l'adresse IP avec l'adresse IP du serveur sur lequel vous souhaitez installer.

hosts

```bash
[default]
mock ansible_host=100.24.146.164
```

Lancez ensuite le script du playbook avec :

```bash
ansible-playbook install_node_nginx.yml -i hosts
```

Les playbooks sont idempotents. Cela signifie que peu importe la fréquence à laquelle vous courez, le résultat est toujours le même. Vous spécifiez le résultat, comme si un fichier devait être absent.
Ansible trouve alors le moyen d'y parvenir.

## Installer l'application mock

Les étapes suivantes consistent à copier les fichiers JavaScript mock et les fichiers de certificats pour Nginx.
Pour exécuter l'application mock Node.js, nous utilisons le gestionnaire de processus [PM2](http://pm2.keymetrics.io/).

run_mock.yml

```yml
---
- name: Start mock and some other stuff
  hosts: mock
  become: true
  remote_user: root

  vars:
    key_file: /etc/nginx/ssl/nginx.key
    cert_file: /etc/nginx/ssl/nginx.crt
    conf_file: /etc/nginx/nginx.conf

  tasks:
    - name: Copy files
      copy: src=../../db.json dest=/home/centos

    - name: Copy package.json
      copy: src=../../package.json dest=/home/centos

    - name: Copy json-server-https
      copy: src=../../json-server-http.js dest=/home/centos

    - name: NPM installation
      shell: npm i
      args:
        chdir: /home/centos

    - name: Install PM2
      npm:
        name: pm2
        global: yes

    - name: Create directories for certificates
      file: path=/etc/nginx/ssl state=directory

    - name: Copy TLS key
      copy: src=files/nginx.key dest={{ key_file }} owner=root mode=0600

    - name: Copy TLS certificate
      copy: src=files/nginx.crt dest={{ cert_file }} owner=root mode=0600

    - name: Copy Nginx config file
      template: src=templates/nginx.conf.j2 dest={{ conf_file }}

    - name: Remove nginx.default
      file:
        path: /etc/nginx/nginx.conf.default
        state: absent

    - name: Restart Nginx
      service:
        name: nginx
        state: restarted

    - name: Start Mock
      shell: pm2 start json-server-http.js
      args:
        chdir: /home/centos
```

Dans ce playbook vous pouvez voir la définition des variables. Elles sont appliquées avec l'interpolation de deux accolades bouclées `{{ var }}`. De plus, un modèle est utilisé pour la génération du fichier de configuration Nginx.
Les modèles d'Ansible sont compatibles avec [Jinja2](http://jinja.pocoo.org/), un Python moteur de modèle.

Quand tout est démarré et que vous pouvez aller dans votre navigateur vers l'IP de votre serveur à l'aide de https. Le navigateur affichera un avertissement d'apparence dangereuse parce que le certificat est auto-signé. Vous devez accepter le certificat et ensuite vous verrez l`application Mock.

Une chose à noter est que ces scripts Ansible ne fonctionnent que sur les machines Linux CentOS.
Ansible n'abstrait pas entre les distributions Linux. Ainsi, si vous souhaitez configurer et déployer sur Ubuntu, vous devrez adapter les scripts.

## Conclusion

Si vous avez de l'expérience avec l'administration système Linux, comprendre un playbook Ansible ne devrait pas être trop difficile.
Avec Infrastructure as Code, il est devenu obligatoire d'automatiser ces tâches d'administration système.
De plus, lorsque vous avez besoin de configurer plusieurs serveurs, des outils comme Ansible sont une nécessité évidente.
Ainsi, les compétences d'Ansible sont précieuses pour les développeurs de Node.js dans le contexte de DevOps.

## Sources et lectures complémentaires

- Infrastructure as Code : Managing Servers in the Cloud, 2016, Kief Morris, O'Reilly Media

- Ansible: Up and Running, 2nd edition, 2017, Rene Moser and Lorin Hochstein, O'Reilly Media

- Code source de cet article : [https://github.com/tderflinger/ansible-node-mock](https://github.com/tderflinger/ansible-node-mock)


large_cow.jpg

medium_cow.jpg

small_cow.jpg

thumbnail_cow.jpg

Les compétences de DevOps deviennent de plus en plus importantes pour les développeurs de Node.js.
Avec Ansible, vous pouvez configurer automatiquement vos serveurs cloud. 
Node.js est une plate-forme de serveur JavaScript populaire. Comment installer un serveur Linux CentOS avec Node.js et Nginx en utilisant Ansible c'est que je veux montrer dans cet article.

Utilisation d'Ansible pour installer Node.js

[Terraform](https://www.terraform.io/) est un outil [Infrastructure as Code (IaC)](https://fr.wikipedia.org/wiki/Infrastructure_as_Code) par HashiCorp. En l'utilisant, vous pouvez créer de manière reproductible des instances de serveurs sur des fournisseurs de cloud comme AWS ou Digital Ocean. Dans cet article, je vous montre comment créer un serveur d'instance [AWS EC2 Spot](https://aws.amazon.com/ec2/spot/) avec Terraform.

Les instances AWS EC2 Spot sont des instances EC2 disponibles à prix réduits. EC2 (Elastic Compute Cloud) est le terme d'Amazon pour leurs serveurs dans leur centre de données que vous pouvez faire pratiquement tout ce que vous voulez avec. Vous pouvez l'utiliser pour exécuter des logiciels.
Dans mon cas, j'utilise une instance pour créer un serveur Linux [CentOS](https://www.centos.org/) à des fins de test. Après le test
l'instance EC2 Spot est détruite.

Tout d'abord, vous devez vous inscrire à AWS et [installer l'outil en ligne de commande AWS (CLI)](https://docs.aws.amazon.com/fr_fr/cli/latest/userguide/cli-chap-install.html).

Terraform accède au CLI AWS et utilise les informations d'identification que vous y avez configurées. Après [l'installation de Terraform](https://learn.hashicorp.com/terraform/getting-started/install.html),
nous définissons un fichier Terraform qui contient la configuration. Le fichier a une terminaison de nom de fichier .tf.

La création d'une instance EC2 est un peu plus compliquée, car il faut définir les règles de mise en réseau et de sécurité.

Vous pouvez trouver le code source sur ma page GitHub sous : https://github.com/tderflinger/terraform-ec2-spot

## VPC

Tout d'abord, vous définissez votre réseau VPC (Virtual Private Cloud) qui est un sous-réseau logiquement isolé du cloud AWS.

```bash
resource "aws_vpc" "test-env" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true
}

resource "aws_subnet" "subnet-uno" {
  # creates a subnet
  cidr_block        = "${cidrsubnet(aws_vpc.test-env.cidr_block, 3, 1)}"
  vpc_id            = "${aws_vpc.test-env.id}"
  availability_zone = "us-east-1a"
}
```

Cette définition utilise le concept d'adresses CIDR. Le concept des adresses réseau est bien expliqué dans l'article [Digital Ocean](https://www.digitalocean.com/community/tutorials/understanding-ip-addresses-subnets-and-cidr-notation-for-networking).

La zone de disponibilité est la us-east-1a, mais vous pouvez choisir celle que vous préférez. Vous pouvez
consultez votre zone de disponibilité dans cet [article de AWS](https://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/using-regions-availability-zones.html).

## Groupes de sécurité

Ensuite, vous devez définir vos groupes de sécurité. Ils sont comme un pare-feu. Dans ce cas, j'autorise
les ports 22 (SSH), 80 (HTTP) et 443 (HTTPS). La partie entrée est l'ingress. La sortie est l'egress et tout peut s'écouler.

```bash
resource "aws_security_group" "ingress-ssh-test" {
  name   = "allow-ssh-sg"
  vpc_id = "${aws_vpc.test-env.id}"

  ingress {
    cidr_blocks = [
      "0.0.0.0/0"
    ]

    from_port = 22
    to_port   = 22
    protocol  = "tcp"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_security_group" "ingress-http-test" {
  name   = "allow-http-sg"
  vpc_id = "${aws_vpc.test-env.id}"

  ingress {
    cidr_blocks = [
      "0.0.0.0/0"
    ]

    from_port = 80
    to_port   = 80
    protocol  = "tcp"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

resource "aws_security_group" "ingress-https-test" {
  name   = "allow-https-sg"
  vpc_id = "${aws_vpc.test-env.id}"

  ingress {
    cidr_blocks = [
      "0.0.0.0/0"
    ]

    from_port = 443
    to_port   = 443
    protocol  = "tcp"
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}
```

## Passerelle Internet

Ensuite, vous devez définir votre adresse IP élastique, c'est-à-dire l'adresse IP IPv4 où vous pouvez atteindre votre serveur.
Vous devez également déclarer quelques ressources comme une [Passerelle Internet](hhttps://docs.aws.amazon.com/fr_fr/vpc/latest/userguide/VPC_Internet_Gateway.html) qui sert de traduction d'adresse réseau (NAT) et de tables de routage.

```bash
resource "aws_eip" "ip-test-env" {
  instance = "${aws_spot_instance_request.test_worker.spot_instance_id}"
  vpc      = true
}

resource "aws_internet_gateway" "test-env-gw" {
  vpc_id = "${aws_vpc.test-env.id}"
}

resource "aws_route_table" "route-table-test-env" {
  vpc_id = "${aws_vpc.test-env.id}"

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = "${aws_internet_gateway.test-env-gw.id}"
  }
}

resource "aws_route_table_association" "subnet-association" {
  subnet_id      = "${aws_subnet.subnet-uno.id}"
  route_table_id = "${aws_route_table.route-table-test-env.id}"
}
```

## Accès SSH

Ensuite, vous voudrez vous connecter en toute sécurité à votre serveur. Pour cela vous définissez la clé publique avec laquelle vous pouvez vous connecter. Vous devez adapter le chemin d'accès du fichier de votre clé publique sur votre système.

```bash
resource "aws_key_pair" "spot_key" {
  key_name   = "spot_key"
  public_key = "${file("/home/xx/.ssh/id_rsa.pub")}"
}
```

## Demande de spot

La dernière pièce du fichier de définition Terraform est le spot actuel demande d'instance. Là, vous devez définir la [Amazon Machine Image (AMI)](https://docs.aws.amazon.com/fr_fr/AWSEC2/latest/UserGuide/AMIs.html). L'AMI est essentiellement un fichier image qui contient le système d'exploitation.
Dans notre cas, c'est CentOS 7.4. Vous trouverez une liste des AMI publics de votre région dans la console AWS sous le menu EC2.

Vous devez également définir un type d'instance approprié.
Sur la page AWS, vous trouverez une liste des [types d'instance](https://aws.amazon.com/fr/ec2/instance-types/?nc1=h_ls).
Les autres propriétés sont des références à la clé SSH, au groupe de sécurité et l'identifiant du sous-réseau.
Dans l'entrée _spotprice_, vous indiquez combien l'instance spot EC2 devrait coûter au maximum par minute.
La _blockdurationminutes_ spécifie l'heure de la durée de l'instance.
Après ce délai, l'instance est automatiquement détruite.

```bash
resource "aws_spot_instance_request" "test_worker" {
  ami                    = "ami-66a7871c"
  spot_price             = "0.016"
  instance_type          = "t3.small"
  spot_type              = "one-time"
  block_duration_minutes = "120"
  wait_for_fulfillment   = "true"
  key_name               = "spot_key"

  security_groups = ["${aws_security_group.ingress-ssh-test.id}", "${aws_security_group.ingress-http-test.id}",
  "${aws_security_group.ingress-https-test.id}"]
  subnet_id = "${aws_subnet.subnet-uno.id}"
}
```

## Exécution de Terraform

Pour appliquer et créer l'instance spot EC2, vous devez appeler Terraform dans le répertoire où vous avez stocké le fichier de définition.

Sachez que votre utilisateur AWS que vous avez configuré dans votre CLI AWS doit avoir le droit de créer des instances EC2. Utilisez la
console [AWS IAM](https://aws.amazon.com/fr/iam/?nc1=h_ls) pour créer les droits nécessaires.

Utilisez les deux commandes suivantes pour lancer la création de l'instance spot EC2:

```bash
terraform init
terraform apply
```

Il vous demandera la région et si tout va bien.
Après la création réussie, il y aura un fichier terraform.tfstate. Vous y trouverez l'adresse IP publique de l'instance.
De plus, dans l'interface web de l'AWS, vous pouvez accéder à la section EC2. Vous y trouverez votre instance et vous pourrez également obtenir l'adresse IP publique.

Vous pouvez alors vous connecter avec SSH à l'instance publique comme ceci:

```bash
ssh root@ip
```

Lorsque vous n'avez plus besoin de l'instance, exécutez la commande destroy:

```bash
terraform destroy
```

## Conclusion

Une instance de serveur sur Amazon EC2 n'est pas aussi facile à configurer que sur d'autres fournisseurs comme Digital Ocean.
Mais vous avez plus de possibilités de configuration.
Avec Terraform, vous avez la possibilité d'un système automatique et facilement configurable. Le mantra de l'infrastructure en tant que code est d'être capable d'automatiser autant que possible toutes les tâches d'administration du système.
Terraform est un outil essentiel à cet égard.

Dans l'un de mes prochains articles, je vous montrerai comment utiliser Ansible pour provisionner l'instance spot EC2.

## Sources et lectures complémentaires

- Infrastructure as Code : Managing Servers in the Cloud, 2016, Kief Morris, O'Reilly Media

- Code source de cet article : [https://github.com/tderflinger/terraform-ec2-spot](https://github.com/tderflinger/terraform-ec2-spot)

- Article de Hasitha Algewatta : [https://medium.com/@hmalgewatta/setting-up-an-aws-ec2-instance-with-ssh-access-using-terraform-c336c812322f](https://medium.com/@hmalgewatta/setting-up-an-aws-ec2-instance-with-ssh-access-using-terraform-c336c812322f
)

- Article de Digital Ocean sur networking : [https://www.digitalocean.com/community/tutorials/understanding-ip-addresses-subnets-and-cidr-notation-for-networking](https://www.digitalocean.com/community/tutorials/understanding-ip-addresses-subnets-and-cidr-notation-for-networking)

- Outil de calcul d'adresse CIDR : [https://www.ultratools.com/tools/netMask](https://www.ultratools.com/tools/netMask)

- Article de Alberto Acuna : [https://blog.albertoacuna.com/using-terraform-to-create-an-ec2-instance-within-a-public-subnet-in-aws](https://blog.albertoacuna.com/using-terraform-to-create-an-ec2-instance-within-a-public-subnet-in-aws)


large_cloud.jpg

medium_cloud.jpg

small_cloud.jpg

thumbnail_cloud.jpg

Terraform est un outil Infrastructure as Code (IaC) de HashiCorp. En l'utilisant, vous pouvez créer de manière reproductible
des instances de serveurs sur des fournisseurs de cloud comme AWS ou Digital Ocean. Dans cet article, je vous montre comment créer un serveur d'instance AWS EC2 Spot avec Terraform.

Créer une instance EC2 Spot avec Terraform

Veuillez entrer une adresse e-mail valide.

Je suis heureux de répondre à toutes les questions que vous pourriez avoir. Ou simplement dis bonjour !

Réflexions par Thomas Derflinger

Cloud catégorie