Einführung

Idee

• Daten aus dem Formular in der Datenbank speichern;
• Senden Sie einen Brief an einen Agenten, der die Frage beantwortet.
• Schreiben Sie möglicherweise einen anderen Dienst, bei dem der Agent die auf der Grundlage derselben Datenbank geleistete Arbeit markiert (nicht im Umfang des Artikels enthalten).

Die Architektur

• Maschine unter hinten, vorne, Bilder usw.,
• Auto mit Basis
• Maschine mit E-Mail-Service.

• AWS Lambda ist die Hauptkomponente, die Code / Logik enthält.
• S3 ist für das Speichern statischer Ressourcen und JS-Skripte verantwortlich.
• CloudFront - für Caching-Mechanismen und multiregionale Unterstützung,
• SES - E-Mail-Service,
• DynamoDB - die Basis zum Speichern von Daten aus dem Formular (von wem, welcher Frage, wohin die Antwort gesendet werden soll),
• Gateway API - HTTP API für unser Lambda,
• Route53 - wird benötigt, wenn Sie einen schönen Domainnamen hinzufügen möchten.

• Wir entfernen uns von der Unterstützung von EC2-Maschinen, kein Debuggen über ssh,
• Einfache Konfiguration: Konfigurieren Sie Drosselung / Caching / Zugriffe mit einem Klick.
• Unterstützt Zugriffsrichtlinien: Rechte einschränken und Zugriff gewähren,
• Protokollierung / Überwachung ab Werk,
• Zahlen Sie nur für verbrauchte Ressourcen / Anfragen.

Demo

Ausbildung

• Aktives AWS-Konto
• aws-cli
• Sam-Cli
• Jdk 11
• Gradle

Projektmontage

1. Erstellen Sie ein Projekt aus einer Vorlage

2. Beschäftigen wir uns mit Sucht

dependencies {
    // AWS
    implementation group: 'com.amazonaws.serverless', name: 'aws-serverless-java-container-core', version: '1.4'
    implementation group: 'com.amazonaws', name: 'aws-lambda-java-core', version: '1.2.0'
    implementation group: 'com.amazonaws', name: 'aws-java-sdk-ses', version: '1.11.670'
    implementation group: 'com.amazonaws', name: 'aws-java-sdk-dynamodb', version: '1.11.670'
    implementation group: 'com.amazonaws', name: 'aws-lambda-java-log4j2', version: '1.1.0'

    // Utils
    implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: '2.10.0'
    implementation group: 'commons-io', name: 'commons-io', version: '2.6'

    // Test
    testImplementation group: 'org.mockito', name: 'mockito-core', version: '3.1.0'
    testImplementation group: 'org.powermock', name: 'powermock-api-mockito2', version: '2.0.4'
    testImplementation group: 'org.powermock', name: 'powermock-module-junit4', version: '2.0.4'
    testImplementation group: 'junit', name: 'junit', version: '4.12'
}

3. Wir schreiben ein Lambda

• Wir ändern die Vorlagenanforderungs- und Antwortklassen für RequestHandler in AwsProxyRequest und ContactUsProxyResponse.

  public class App implements RequestHandler<AwsProxyRequest, ContactUsProxyResponse>
  ...
  public ContactUsProxyResponse handleRequest(AwsProxyRequest request, Context context) 

  
  
• AwsClientFactory AWS SDK-.

  /**
   * Just an util class for an eager initialization of sdk clients.
   */
  public class AwsClientFactory {
  
      private static final Logger LOG = LogManager.getLogger(AwsClientFactory.class);
  
      private final AmazonSimpleEmailService sesClient;
      private final DynamoDB dynamoDB;
  
      /**
       * AWS regions should be env variables if you want to generalize the solution.
       */
      AwsClientFactory() {
          LOG.debug("AWS clients factory initialization.");
          sesClient = AmazonSimpleEmailServiceClient.builder().withRegion(Regions.EU_WEST_1).build();
          AmazonDynamoDB dynamoDBClient = AmazonDynamoDBClientBuilder.standard().withRegion(Regions.EU_WEST_1).build();
          dynamoDB = new DynamoDB(dynamoDBClient);
      }
  
      DynamoDB getDynamoDB() {
          return dynamoDB;
      }
  
      AmazonSimpleEmailService getSesClient() {
          return sesClient;
      }
  
  }
  

  
  
• ObjectMapper .

  
  private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
  private static final AwsClientFactory AWS_CLIENT_FACTORY = new AwsClientFactory();
  

  
  
• .

  
   private SendEmailResult sendEmail(ContactUsRequest contactUsRequest) {
          String emailTemplate = getEmailTemplate();
          String email = fillTemplate(emailTemplate, contactUsRequest);
  
          SendEmailRequest sendEmailRequest =
                  new SendEmailRequest(
                          System.getenv("SENDER_EMAIL"),
                          new Destination(List.of(System.getenv("RECIPIENT_EMAIL"))),
                          new Message()
                                  .withSubject(
                                          new Content()
                                                  .withCharset(UTF_8.name())
                                                  .withData(contactUsRequest.getSubject()))
                                  .withBody(new Body()
                                          .withHtml(new Content()
                                                  .withCharset(UTF_8.name())
                                                  .withData(email))));
          LOG.info("Email template is ready");
          return AWS_CLIENT_FACTORY.getSesClient().sendEmail(sendEmailRequest);
  }
  
  private String fillTemplate(String emailTemplate, ContactUsRequest contactUsRequest) {
          return String.format(
                  emailTemplate,
                  contactUsRequest.getUsername(),
                  contactUsRequest.getEmail(),
                  contactUsRequest.getPhone(),
                  contactUsRequest.getQuestion());
  }
  
  private String getEmailTemplate() {
          try {
              return IOUtils.toString(
                      Objects.requireNonNull(this.getClass().getClassLoader()
                                                 .getResourceAsStream("email_template.html")),
                      UTF_8);
          } catch (IOException e) {
              throw new RuntimeException("Loading an email template failed.", e);
          }
  }
  
  private void addEmailDetailsToDb(ContactUsRequest contactUsRequest, SendEmailResult sendEmailResult) {
          AWS_CLIENT_FACTORY.getDynamoDB().getTable("ContactUsTable")
                            .putItem(new Item()
                                    .withPrimaryKey("Id", sendEmailResult.getMessageId())
                                    .withString("Subject", contactUsRequest.getSubject())
                                    .withString("Username", contactUsRequest.getUsername())
                                    .withString("Phone", contactUsRequest.getPhone())
                                    .withString("Email", contactUsRequest.getEmail())
                                    .withString("Question", contactUsRequest.getQuestion()));
  }
  

  
  
• .

  
  private ContactUsProxyResponse buildResponse(int statusCode, String body) {
          ContactUsProxyResponse awsProxyResponse =
                  new ContactUsProxyResponse();
          awsProxyResponse.setStatusCode(statusCode);
          awsProxyResponse.setBody(getBodyAsString(body));
          awsProxyResponse.addHeader(CONTENT_TYPE, ContentType.APPLICATION_JSON.toString());
          awsProxyResponse.addHeader("Access-Control-Allow-Origin", "*");
          return awsProxyResponse;
  }
  
   private String getBodyAsString(String body) {
          try {
              return OBJECT_MAPPER.writeValueAsString(new ContactUsResponseBody(body));
          } catch (JsonProcessingException e) {
              throw new RuntimeException("Writing ContactUsResponseBody as string failed.", e);
          }
  }
  

  
  
• . «// WARMING UP».

  
  if (Optional.ofNullable(request.getMultiValueHeaders()).map(headers -> headers.containsKey("X-WARM-UP")).orElse(FALSE)) {
              LOG.info("Lambda was warmed up");
              return buildResponse(201, "Lambda was warmed up. V1");
  }
  

  
  
• handleRequest()

  
  @Override
  public ContactUsProxyResponse handleRequest(AwsProxyRequest request, Context context) {
          LOG.info("Request was received");
          LOG.debug(getAsPrettyString(request));
  
          if (Optional.ofNullable(request.getMultiValueHeaders()).map(headers -> headers.containsKey("X-WARM-UP")).orElse(FALSE)) {
              LOG.info("Lambda was warmed up");
              return buildResponse(201, "Lambda was warmed up. V1");
          }
  
          ContactUsRequest contactUsRequest = getContactUsRequest(request);
  
          SendEmailResult sendEmailResult = sendEmail(contactUsRequest);
          LOG.info("Email was sent");
  
          addEmailDetailsToDb(contactUsRequest, sendEmailResult);
          LOG.info("DB is updated");
  
          return buildResponse(200,
                  String.format("Message %s has been sent successfully.", sendEmailResult.getMessageId()));
  }
  

  
  

LambdaLogger logger = context.getLogger();

4. Wir schreiben Tests

5. Wir schreiben eine Vorlage für SAM-Ressourcen

CodeUri: contact-us-function
Handler: com.gralll.sam.App::handleRequest
Runtime: java8
MemorySize: 256

AutoPublishAlias: live
DeploymentPreference:
  Type: Canary10Percent10Minutes

Events:
  ContactUs:
    Type: Api
    Properties:
      Path: /contact
      Method: post

Policies:
  - AWSLambdaExecute
  - Version: '2012-10-17'
    Statement:
      - Effect: Allow
        Action:
          - ses:SendEmail
          - ses:SendRawEmail
        Resource: 'arn:aws:ses:eu-west-1:548476639829:identity/aleksandrgruzdev11@gmail.com'
      - Effect: Allow
        Action:
          - dynamodb:List*
        Resource: '*'
      - Effect: Allow
        Action:
          - dynamodb:Get*
          - dynamodb:PutItem
          - dynamodb:DescribeTable
        Resource: 'arn:aws:dynamodb:*:*:table/ContactUsTable'

ContactUsTable:
  Type: AWS::Serverless::SimpleTable
  Properties:
    PrimaryKey:
      Name: Id
      Type: String
    TableName: ContactUsTable
    ProvisionedThroughput:
      ReadCapacityUnits: 2
      WriteCapacityUnits: 2

Globals:
  Function:
    Timeout: 15
  Api:
    Cors:
      AllowOrigin: "'*'"
      AllowHeaders: "'Content-Type,X-WARM-UP,X-Amz-Date,Authorization,X-Api-Key'"

Outputs:
  ContactUsApi:
    Description: "API Gateway endpoint URL for Prod stage for ContactUs function"
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/contact/"
  ContactUsFunction:
    Description: "ContactUs Lambda Function ARN"
    Value: !GetAtt ContactUsFunction.Arn
  ContactUsFunctionIamRole:
    Description: "Implicit IAM Role created for ContactUs function"
    Value: !GetAtt ContactUsFunctionRole.Arn

6. Wir fahren mit der Bereitstellung fort

F:\aws\projects\contact-us-sam-app>sam build
Building resource 'ContactUsFunction'
Running JavaGradleWorkflow:GradleBuild
Running JavaGradleWorkflow:CopyArtifacts

Build Succeeded

Built Artifacts  : .aws-sam\build
Built Template   : .aws-sam\build\template.yaml

Commands you can use next
=========================
[*] Invoke Function: sam local invoke
[*] Deploy: sam deploy –guided

aws s3 mb s3://bucket-name

sam package --output-template-file packaged.yaml --s3-bucket <YOUR_BACKET>

F:\aws\projects\contact-us-sam-app>sam package --output-template-file packaged.yaml --s3-bucket contact-us-sam-app
Uploading to ea0c122c06a50d9676fbf9000a80a3bf  9212768 / 9212768.0  (100.00%)

Successfully packaged artifacts and wrote output template to file packaged.yaml.
Execute the following command to deploy the packaged template
sam deploy --template-file F:\aws\projects\contact-us-sam-app\packaged.yaml --stack-name <YOUR STACK NAME>

sam deploy --template-file packaged.yaml --region eu-west-1 --capabilities CAPABILITY_IAM --stack-name contact-us-sam-app

7. Überprüfen Sie den Status von CloudFormation

Successfully created/updated stack - contact-us-sam-app in eu-west-1

• ServerlessRestApi
• ServerlessRestApiDeployment
• ServerlessRestApiProdStage

8. HTML ContactUs-Formular

$("#url-input").val("https://4ykskscuq0.execute-api.eu-west-1.amazonaws.com/Prod/contact");
$("#name-input").val("Mike");
$("#email-input").val("Mike@somemail.com");
$("#phone-input").val("+79999999999");
$("#description-input").val("How much does it cost?");

• Erstellen Sie einen neuen S3-Bucket.
• Wir laden die HTML-Datei in den Bucket, indem wir die Option auswählen, die Datei öffentlich zu machen.
• Wir gehen in den Eimer, in den wir die Datei hochgeladen haben.
• Gehen Sie zu Eigenschaften, aktivieren Sie das Hosting der statischen Website und sehen Sie Ihren neuen öffentlich verfügbaren Endpunkt.

9. Gesundheitscheck

Erfolgreich: Die Nachricht 0102016f28b06243-ae897a1e-b805-406b-9987-019f21547682-000000 wurde erfolgreich gesendet.

Zusammenfassen

• Free Tier , , .
• 1-2 . /.
• , , .
• Serverless . , — . SAM AWS. AWS , , .
• Lambda , .
• Serverless , , . ELK/Promethes/Grafana .
• , API. API Key, IAM , .
• Nun, wahrscheinlich ist das Grundlegendste Serverlos. Sie müssen nicht darüber nachdenken, für welche EC2-Instanz Sie bezahlen müssen, wie Sie den Zugriff darauf konfigurieren, wie Sie Warnungen im Falle eines Anwendungsabsturzes konfigurieren, die automatische Skalierung konfigurieren usw.

• Kaltstart. Besonders wichtig bei Verwendung synchroner Abfragen und Sprachen wie Java oder C #. Das Problem wird durch Aufwärmen mäßig gelöst, aber es ist besser, im Voraus über eine solche Lösung nachzudenken und die Kosten und möglichen Vorteile zu vergleichen
• . 3GB , 2 , , - Fargate, , .
• API, , .
• / 1-2 Serverless, .
• Wenn Sie bereits über die Infrastruktur für die Entwicklung von Microservices und CI / CD in Coober verfügen, ist es erneut problematisch, (insbesondere für Manager) die Notwendigkeit zu argumentieren, einen anderen CI / CD-Prozess zu unterstützen.
• Nun, wo ohne zu testen. Und das Lambda auf Durchsatz zu testen ist ziemlich schwierig, da es sich immer noch von den üblichen Leistungstests unterscheidet und viele Faktoren berücksichtigt werden müssen.

PS

• GitHub-Projekt
• Laden Sie AWS-CLI herunter
• Laden Sie SAM-CLI herunter
• AWS-CLI-Konfiguration
• Infrastruktur als Code
• Erfahrung mit Terraform
• Beschreibung der SAM-Ressourcen
• AWS Lambda-Funktions-Aliase
• Erweiterte Lambda-Bereitstellung
• SAM Api-Ressourcenkonfiguration
• AWS IAM
• SES
• Read/Write capacity DynamoDB
• SAM/CloudFormation
• Parameters
• CloudFormation