aws-lambda
Framework sans serveur

Android C# Language firebase Go iOS Java Language JavaScript MySQL Node.js Python Language
Recherche…


Introduction

Le framework d'application open-source pour construire facilement des architectures sans serveur sur AWS Lambda & plus. Cette section comprend comment configurer une infrastructure sans serveur pour le développement d'applications avec des exemples pertinents.

Remarques

"Serverless" est un framework: https://serverless.com/

Sans serveur

Installer sans serveur au niveau mondial 

npm install serverless -g

Créez une fonction AWS Lamdba dans Node.js 

serverless create --template aws-nodejs

Exemple de handler.js 

'use strict';

// Your first function handler
module.exports.hello = (event, context, cb) => cb(null,
  { message: 'Go Serverless v1.0! Your function executed successfully!', event }
);

// You can add more handlers here, and reference them in serverless.yml

Déployer sur un compte AWS en direct 

serverless deploy

Créer une opération CRUD simple

Créer une opération CRUD simple à l'aide d'une structure sans serveur

Installer le framework Serverless globalement 

npm install serverless -g

Créer un service Lambda simple 

serverless create --template aws-nodejs --path myService

Accédez au répertoire myService qu'il doit contenir

  1. serverless.yml
  2. handler.js
  3. event.json

Toutes les configurations de service sans serveur sont gérées par serverless.yml
Changer son contenu pour définir le service CRUD.

Exemple de fichier serverless.yml 

service: serverless-crud

provider:
  name: aws
  runtime: nodejs4.3
  region: us-east-1
  stage: dev
  iamRoleStatements:
    - Effect: Allow
      Action:
        - dynamodb:DescribeTable
        - dynamodb:Query
        - dynamodb:Scan
        - dynamodb:GetItem
        - dynamodb:PutItem
        - dynamodb:UpdateItem
        - dynamodb:DeleteItem
      Resource: "arn:aws:dynamodb:us-east-1:*:*"

functions:
  create:
    handler: handler.create
    events:
      - http:
          path: todos
          method: post
          cors: true
  readAll:
    handler: handler.readAll
    events:
      - http:
          path: todos
          method: get
          cors: true
  readOne:
    handler: handler.readOne
    events:
      - http:
          path: todos/{id}
          method: get
          cors: true
  update:
    handler: handler.update
    events:
      - http:
          path: todos/{id}
          method: put
          cors: true
  delete:
    handler: handler.delete
    events:
      - http:
          path: todos/{id}
          method: delete
          cors: true

resources:
  Resources:
    TodosDynamoDbTable:
      Type: 'AWS::DynamoDB::Table'
      DeletionPolicy: Retain
      Properties:
        AttributeDefinitions:
          -
            AttributeName: id
            AttributeType: S
        KeySchema:
          -
            AttributeName: id
            KeyType: HASH
        ProvisionedThroughput:
          ReadCapacityUnits: 1
          WriteCapacityUnits: 1
        TableName: 'todos'

Ce fichier définit

  1. Langage de programmation Lambda
  2. Stratégie d'exécution de la fonction Lambda
  3. Création de table Dynamodb et sa politique
  4. Point de terminaison HTTP (point de terminaison API Gateway)

Ensuite, vous devez définir la fonction lambda (ex. Node.js) dans le fichier handler.js que vous pouvez définir. 
'use strict';

const todosCreate = require('./todos-create.js');
const todosReadAll = require('./todos-read-all.js');
const todosReadOne = require('./todos-read-one.js');
const todosUpdate = require('./todos-update.js');
const todosDelete = require('./todos-delete.js');

module.exports.create = (event, context, callback) => {
  todosCreate(event, (error, result) => {
    const response = {
      statusCode: 200,
      headers: {
        "Access-Control-Allow-Origin" : "*"
      },
      body: JSON.stringify(result),
    };

    context.succeed(response);
  });
};

module.exports.readAll = (event, context, callback) => {
  todosReadAll(event, (error, result) => {
    const response = {
      statusCode: 200,
      headers: {
        "Access-Control-Allow-Origin" : "*"
      },
      body: JSON.stringify(result),
    };

    context.succeed(response);
  });
};

module.exports.readOne = (event, context, callback) => {
  todosReadOne(event, (error, result) => {
    const response = {
      statusCode: 200,
      headers: {
        "Access-Control-Allow-Origin" : "*"
      },
      body: JSON.stringify(result),
    };

    context.succeed(response);
  });
};

module.exports.update = (event, context, callback) => {
  todosUpdate(event, (error, result) => {
    const response = {
      statusCode: 200,
      headers: {
        "Access-Control-Allow-Origin" : "*"
      },
      body: JSON.stringify(result),
    };

    context.succeed(response);
  });
};

module.exports.delete = (event, context, callback) => {
  todosDelete(event, (error, result) => {
    const response = {
      statusCode: 200,
      headers: {
        "Access-Control-Allow-Origin" : "*"
      },
      body: JSON.stringify(result),
    };



    context.succeed(response);
  });
};

Ensuite, vous devez créer de nouveaux fichiers pour définir vos fonctions CRUD
Créez ces fichiers

  1. todos-create.js
  2. todos-read-all.js
  3. todos-read-one.js
  4. todos-update.js
  5. todos-delete.js

Définissez ensuite ces fonctions dans chaque fichier.

pour todos-create.js 

'use strict';

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();
const uuid = require('uuid');

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

  data.id = uuid.v1();
  data.updatedAt = new Date().getTime();

  const params = {
    TableName: 'todos',
    Item: data
  };

  return dynamoDb.put(params, (error, data) => {
    if (error) {
      callback(error);
    }
    callback(error, params.Item);
  });
};

Pour todos-read-all.js 

    'use strict';
    
    const AWS = require('aws-sdk');
    const dynamoDb = new AWS.DynamoDB.DocumentClient();
    
    module.exports = (event, callback) => {
      const params = {
        TableName: 'todos',
      };
    
      return dynamoDb.scan(params, (error, data) => {
        if (error) {
          callback(error);
        }
        callback(error, data.Items);
      });
    };


For todos-read-one.js <br>

'use strict';

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();

module.exports = (event, callback) => {
  const params = {
    TableName: 'todos',
    Key: {
      id: event.pathParameters.id
    }
  };

  return dynamoDb.get(params, (error, data) => {
    if (error) {
      callback(error);
    }
    callback(error, data.Item);
  });
};

Pour todos-update.js 

'use strict';

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();

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

  data.id = event.pathParameters.id;
  data.updatedAt = new Date().getTime();

  const params = {
    TableName : 'todos',
    Item: data
  };

  return dynamoDb.put(params, (error, data) => {
    if (error) {
      callback(error);
    }
    callback(error, params.Item);
  });
};

Pour todos-delete.js 

'use strict';

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();

module.exports = (event, callback) => {
  const params = {
    TableName : 'todos',
    Key: {
      id: event.pathParameters.id
    }
  };

  return dynamoDb.delete(params, (error, data) => {
    if (error) {
      callback(error);
    }
    callback(error, params.Key);
  });
};

Pour l'exécution, vous devez installer les dépendances npm

  1. npm init initialisation npm
  2. npm install aws-sdk --save installez aws-sdk
  3. npm install uuid --save

Déploiement
Maintenant, vous pouvez déployer ces projets
cd myService vérifiez que vous êtes dans le répertoire du projet, alors vous pouvez déployer votre code 

serverless deploy

Utiliser le point de fin
Si vous avez déployé avec succès, vous visualisez les noms de pont de fin de passerelle API dans votre console.

Test Create End Point 

curl -X POST https://XXXX.execute-api.region.amazonaws.com/dev/todos --data '{ "body" : "Learn Serverless" }'

Test de lecture End Point (lire la suite) 

curl https://XXXX.execute-api.region.amazonaws.com/dev/todos

Test de lecture End Point (Lire One) 

curl https://XXXX.execute-api.region.amazonaws.com/dev/todos/<id>

Test du point de fin de la mise à jour 

curl -X PUT https://XXXX.execute-api.region.amazonaws.com/dev/todos/<id> --data '{ "body" : "Understand Serverless" }'

Test du point de fin de suppression 

`curl -X DELETE https://XXXX.execute-api.region.amazonaws.com/dev/todos/<id`>


Modified text is an extract of the original Stack Overflow Documentation
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow