Implementierung

• Erstellen einer Amazon-DynamoDB-Tabelle

  Verwenden Sie die Amazon-DynamoDB-Konsole, um eine neue DynamoDB-Tabelle zu erstellen. 

  1. Klicken Sie in der Amazon-DynamoDB-Konsole auf Tabelle erstellen.
  2. Geben Sie Rides als Tabellennamen ein. Bitte beachten Sie die Groß- und Kleinschreibung.
  3. Geben Sie RideId als Partitionsschlüsselein und wählen Sie Zeichenfolge als Schlüsseltyp aus. Bitte beachten Sie die Groß- und Kleinschreibung.
  4. Stellen Sie sicher, dass im Abschnitt Tabelleneinstellungen die Option Standardeinstellungen ausgewählt ist, und wählen Sie Tabelle erstellen aus. 
  5. Warten Sie auf der Seite Tabellen, bis Ihre Tabellenerstellung abgeschlossen ist. Sobald der Vorgang abgeschlossen ist, lautet der Status Aktiv. Wählen Sie Ihren Tabellennamen aus.
  6. Wählen Sie in der Registerkarte Übersicht > Allgemeine Informationen  Ihrer neuen Tabelle die Option Zusätzliche Informationen aus. Kopieren Sie die ARN. Sie benötigen diese im nächsten Abschnitt.
     
• Erstellen einer IAM-Rolle für Ihre Lambda-Funktion

  Jeder Lambda-Funktion ist eine IAM-Rolle zugeordnet. Die Rolle definiert, mit welchen anderen AWS-Services die Funktion interagieren darf. Für dieses Tutorial müssen Sie eine IAM-Rolle erstellen, die Ihrer Lambda-Funktion Berechtigungen zum Schreiben von Protokollen in Amazon CloudWatch Logs und Zugriff zum Schreiben von Elementen in Ihre DynamoDB-Tabelle erteilt.

  1. Wählen Sie in der IAM-Konsole im linken Navigationsbereich Rollen und dann Rolle erstellen aus.
  2. Wählen Sie im Abschnitt Vertrauenswürdiger Entitätstyp die Option AWS-Service aus. Wählen Sie für AnwendungsfallLambda und dann Weiter aus. 
     Hinweis: Durch das Auswählen einer Rolle wird automatisch eine Vertrauensrichtlinie für Ihre Rolle erstellt, mit der AWS-Services diese Rolle in Ihrem Auftrag übernehmen dürfen. Wenn Sie diese Rolle mit der CLI, AWS CloudFormation oder einem anderen Mechanismus erstellen, geben Sie direkt eine Vertrauensrichtlinie an.
  3. Geben Sie AWSLambdaBasicExecutionRole in das Filtertextfeld ein und drücken Sie die Eingabetaste. 
  4. Aktivieren Sie das Kontrollkästchen neben dem Richtliniennamen AWSLambdaBasicExecutionRole und wählen Sie Weiter aus.
  5. Geben Sie WildRydesLambda als Rollennamen ein. Behalten Sie die Standardeinstellungen für die anderen Parameter bei.
  6. Wählen Sie Rolle erstellen.
  7. Geben Sie in das Filterfeld auf der Seite Rollen WildRydesLambda ein und wählen Sie den Namen der Rolle aus, die Sie gerade erstellt haben.
  8. Wählen Sie auf der Registerkarte Berechtigungen unter Berechtigungen hinzufügen die Option Inline-Richtlinie erstellen aus.
  9. Geben Sie im Abschnitt Service auswählen DynamoDB in die Suchleiste ein und wählen Sie DynamoDB aus, wenn es angezeigt wird.
  10. Wählen Sie Aktionen auswählen.
  11. Geben Sie im Abschnitt Zulässige Aktionen PutItem in die Suchleiste ein und aktivieren Sie das Kontrollkästchen neben PutItem, wenn es angezeigt wird.
  12. Wählen Sie im Abschnitt Ressourcen , wenn die Option Spezifisch ausgewählt ist, den Link ARN hinzufügen aus.
  13. Wählen Sie die Registerkarte Text aus. Fügen Sie den ARN der Tabelle ein, die Sie in DynamoDB erstellt haben (Schritt 6 im vorherigen Abschnitt), und wählen Sie ARNs hinzufügen aus.
  14. Wählen Sie Weiter aus.
  15. Geben Sie DynamoDBWriteAccess als Namen für die Richtlinie ein und wählen Sie Richtlinie erstellen aus.
• Erstellen einer Lambda-Funktion zum Verarbeiten von Anforderungen

  AWS Lambda führt Ihren Code als Reaktion von Ereignissen wie etwa eine HTTP-Anforderung aus. In diesem Schritt erstellen Sie die Kernfunktion, die API-Anforderungen von der Webanwendung zum Bereitstellen eines Einhorns verarbeitet. Im nächsten Modul verwenden Sie Amazon API Gateway zum Erstellen einer RESTful API, die einen HTTP-Endpunkt bereitstellt, der über die Browser Ihrer Benutzer aufgerufen werden kann. Anschließend verbinden Sie die in diesem Schritt erstellte Lambda-Funktion mit der API, um ein vollständig funktionsfähiges Backend für Ihre Webanwendung zu erstellen.

  Verwenden Sie die AWS-Lambda-Konsole, um eine neue Lambda-Funktion namens RequestUnicorn zu erstellen, die die API-Anfragen verarbeitet. Verwenden Sie die folgende Beispielimplementierung requestUnicorn.js für Ihren Funktionscode. Kopieren Sie sie einfach aus der Datei und fügen Sie sie im Editor der AWS-Lambda-Konsole ein.

  Stellen Sie sicher, dass Sie Ihre Funktion so konfigurieren, dass sie die IAM-Rolle WildRydesLambda verwendet, die Sie im vorherigen Abschnitt erstellt haben.
  

  1. Wählen Sie in der AWS-Lambda-Konsole Funktion erstellen aus.
  2. Behalten Sie die Auswahl der Standardkarte Von Grund auf neu erstellen bei.
  3. Geben Sie RequestUnicorn in das Feld Funktionsname ein.
  4. Wählen Sie Node.js 16.x für die Laufzeit aus (neuere Versionen von Node.js funktionieren in diesem Tutorial nicht).
  5. Wählen Sie im Dropdownmenü Standardausführungsrolle ändern die Option Vorhandene Rolle verwenden aus.
  6. Wählen Sie WildRydesLambda aus dem Dropdown-Menü Vorhandene Rolle aus.
  7. Klicken Sie auf Funktion erstellen.
  8. Scrollen Sie nach unten zum Abschnitt Codequelle und ersetzen Sie den vorhandenen Code im Code-Editor von index.js durch den Inhalt von requestUnicorn.js. Der folgende Codeblock zeigt die Datei requestUnicorn.js an. Kopieren Sie diesen Code und fügen Sie ihn in die Registerkarte index.js des Code-Editors ein.

  const randomBytes = require('crypto').randomBytes;
  const AWS = require('aws-sdk');
  const ddb = new AWS.DynamoDB.DocumentClient();
  
  const fleet = [
      {
          Name: 'Angel',
          Color: 'White',
          Gender: 'Female',
      },
      {
          Name: 'Gil',
          Color: 'White',
          Gender: 'Male',
      },
      {
          Name: 'Rocinante',
          Color: 'Yellow',
          Gender: 'Female',
      },
  ];
  
  exports.handler = (event, context, callback) => {
      if (!event.requestContext.authorizer) {
        errorResponse('Authorization not configured', context.awsRequestId, callback);
        return;
      }
  
      const rideId = toUrlString(randomBytes(16));
      console.log('Received event (', rideId, '): ', event);
  
      // Because we're using a Cognito User Pools authorizer, all of the claims
      // included in the authentication token are provided in the request context.
      // This includes the username as well as other attributes.
      const username = event.requestContext.authorizer.claims['cognito:username'];
  
      // The body field of the event in a proxy integration is a raw string.
      // In order to extract meaningful values, we need to first parse this string
      // into an object. A more robust implementation might inspect the Content-Type
      // header first and use a different parsing strategy based on that value.
      const requestBody = JSON.parse(event.body);
  
      const pickupLocation = requestBody.PickupLocation;
  
      const unicorn = findUnicorn(pickupLocation);
  
      recordRide(rideId, username, unicorn).then(() => {
          // You can use the callback function to provide a return value from your Node.js
          // Lambda functions. The first parameter is used for failed invocations. The
          // second parameter specifies the result data of the invocation.
  
          // Because this Lambda function is called by an API Gateway proxy integration
          // the result object must use the following structure.
          callback(null, {
              statusCode: 201,
              body: JSON.stringify({
                  RideId: rideId,
                  Unicorn: unicorn,
                  Eta: '30 seconds',
                  Rider: username,
              }),
              headers: {
                  'Access-Control-Allow-Origin': '*',
              },
          });
      }).catch((err) => {
          console.error(err);
  
          // If there is an error during processing, catch it and return
          // from the Lambda function successfully. Specify a 500 HTTP status
          // code and provide an error message in the body. This will provide a
          // more meaningful error response to the end client.
          errorResponse(err.message, context.awsRequestId, callback)
      });
  };
  
  // This is where you would implement logic to find the optimal unicorn for
  // this ride (possibly invoking another Lambda function as a microservice.)
  // For simplicity, we'll just pick a unicorn at random.
  function findUnicorn(pickupLocation) {
      console.log('Finding unicorn for ', pickupLocation.Latitude, ', ', pickupLocation.Longitude);
      return fleet[Math.floor(Math.random() * fleet.length)];
  }
  
  function recordRide(rideId, username, unicorn) {
      return ddb.put({
          TableName: 'Rides',
          Item: {
              RideId: rideId,
              User: username,
              Unicorn: unicorn,
              RequestTime: new Date().toISOString(),
          },
      }).promise();
  }
  
  function toUrlString(buffer) {
      return buffer.toString('base64')
          .replace(/\+/g, '-')
          .replace(/\//g, '_')
          .replace(/=/g, '');
  }
  
  function errorResponse(errorMessage, awsRequestId, callback) {
    callback(null, {
      statusCode: 500,
      body: JSON.stringify({
        Error: errorMessage,
        Reference: awsRequestId,
      }),
      headers: {
        'Access-Control-Allow-Origin': '*',
      },
    });
  }

  Code snippet copied

  Kopieren

      9. Wählen Sie Bereitstellen.

• Eigene Implementierung überprüfen

  In diesem Modul testen Sie die Funktion, die Sie mithilfe der AWS-Lambda-Konsole erstellt haben. Im nächsten Modul fügen Sie eine REST-API mit API Gateway hinzu, damit Sie Ihre Funktion über die browserbasierte Anwendung aufrufen können, die Sie im ersten Modul bereitgestellt haben.

  1. Wählen Sie in der Funktion requestUnicorn, die Sie im vorherigen Abschnitt erstellt haben, im Abschnitt Codequelle die Option Testen aus und wählen Sie in der Dropdownliste die Option Testereignis konfigurieren aus.
  2. Behalten Sie die Standardauswahl Neues Ereignis erstellen bei.
  3. Geben Sie TestRequestEvent im Feld Ereignisname ein.
  4. Kopieren Sie das folgende Testereignis und fügen Sie es in den Abschnitt Ereignis-JSON ein:
     

  {
      "path": "/ride",
      "httpMethod": "POST",
      "headers": {
          "Accept": "*/*",
          "Authorization": "eyJraWQiOiJLTzRVMWZs",
          "content-type": "application/json; charset=UTF-8"
      },
      "queryStringParameters": null,
      "pathParameters": null,
      "requestContext": {
          "authorizer": {
              "claims": {
                  "cognito:username": "the_username"
              }
          }
      },
      "body": "{\"PickupLocation\":{\"Latitude\":47.6174755835663,\"Longitude\":-122.28837066650185}}"
  }

  Code snippet copied

  Kopieren

      5. Wählen Sie Speichern aus.

      6. Wählen Sie im Abschnitt Codequelle Ihrer Funktion die Option Testen und dann TestRequestEvent aus der Dropdownliste aus.

      7.  Wählen Sie auf der Registerkarte Test die Option Testen aus.

      8. Erweitern Sie in der Meldung Funktion wird ausgeführt:erfolgreich, die angezeigt wird, das Dropdownmenü Details.

      9. Stellen Sie sicher, dass das Funktionsergebnis wie folgt aussieht:
  

  {
      "statusCode": 201,
      "body": "{\"RideId\":\"SvLnijIAtg6inAFUBRT+Fg==\",\"Unicorn\":{\"Name\":\"Rocinante\",\"Color\":\"Yellow\",\"Gender\":\"Female\"},\"Eta\":\"30 seconds\"}",
      "headers": {
          "Access-Control-Allow-Origin": "*"
      }
  }

  Code snippet copied

  Kopieren