Serverlös utveckling med AWS Lambda · Lektion

AWS Serverless Application Model (SAM)

Lär dig definiera, utveckla och distribuera serverless-applikationer med AWS SAM, ett ramverk med öppen källkod för utveckling på AWS

Lektion 1 av 411 steg

AWS Serverless Application Model (SAM) är en gratis lektion i Serverlös utveckling med AWS Lambda på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Serverlös utveckling med AWS Lambda, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Serverlös utveckling med AWS Lambda innehåller totalt 4 lektioner.

Förenkla serverlöst med AWS SAM

AWS Serverless Application Model (SAM) är ett ramverk med öppen källkod som förenklar utveckling och driftsättning av serverlösa applikationer på AWS.

Det utökar AWS CloudFormation och ger er en särskild, enklare syntax för att definiera serverlösa resurser som Lambda-funktioner, API Gateways och DynamoDB-tabeller. SAM hjälper er att hantera hela den serverlösa applikationen som en enda enhet.

SAM-mallen: ritningen

Kärnan i varje SAM-applikation är filen template.yaml. Den här YAML- (eller JSON-)filen fungerar som en ritning och beskriver alla serverlösa resurser som ingår i applikationen.

SAM-mallar är i grunden AWS CloudFormation-mallar, men de innehåller den viktiga egenskapen Transform, som aktiverar SAM:s förenklade syntax anpassad för serverlösa applikationer.

En SAM-malls uppbyggnad

Nu tittar vi på de viktigaste avsnitten i en template.yaml-fil:

AWSTemplateFormatVersion: Standardversion för CloudFormation.
Transform: AWS::Serverless-2016-10-31: Detta är avgörande! Det talar om för CloudFormation att SAM:s förenklade syntax ska användas.
Description: En kort beskrivning av applikationen.
Resources: Här definierar ni alla serverlösa komponenter, till exempel Lambda-funktioner, API:er och databaser.

Definiera en serverlös funktion

I SAM definierar ni en Lambda-funktion med resurstypen AWS::Serverless::Function. Ni anger viktiga egenskaper som körmiljö, startpunkt (handler), minne och hur funktionen utlöses.

Type: AWS::Serverless::Function: Identifierar resursen som en Lambda-funktion.
Handler: Funktionen i er kod som AWS Lambda anropar för att starta körningen (till exempel app.lambda_handler).
Runtime: Programmeringsspråkets körmiljö (till exempel python3.9, nodejs16.x).
CodeUri: Den lokala sökvägen till funktionens källkod.
Events: Anger hur funktionen anropas (till exempel en API Gateway-slutpunkt).

Vår Lambda-handler för Hello World

Här är en enkel Python-Lambda-funktion. Det är koden som körs när vår serverlösa funktion anropas. Den returnerar bara meddelandet Hello from Lambda!

import json

def lambda_handler(event, context):
    # Log the event for debugging purposes
    print("Received event: " + json.dumps(event))

    # Basic response for API Gateway
    response = {
        "statusCode": 200,
        "body": json.dumps("Hello from Lambda!")
    }
    return response

SAM-mall för vår funktion

Nu definierar vi vår Lambda-funktion för Hello World i en template.yaml. Vi konfigurerar den så att den utlöses av en API Gateway-GET-begäran på sökvägen /hello.

Den här mallen förutsätter att er Python-kod (app.py) finns i en mapp med namnet hello_world/ bredvid filen template.yaml.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A simple "Hello World" serverless application.

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: app.lambda_handler
      Runtime: python3.9
      CodeUri: hello_world/
      MemorySize: 128
      Timeout: 30
      Events:
        HelloWorldApi:
          Type: Api
          Properties:
            Path: /hello
            Method: GET

SAM CLI: ert verktyg för driftsättning

AWS SAM Command Line Interface (CLI) är ert huvudsakliga verktyg för att utveckla och driftsätta SAM-applikationer. Det tillhandahåller kommandon för att initiera projekt, bygga beroenden, testa lokalt och driftsätta applikationen på AWS.

sam init: Starta ett nytt serverlöst projekt.
sam build: Paketera applikationskoden och dess beroenden.
sam deploy: Driftsätt applikationen med AWS CloudFormation.

Bygga er SAM-applikation

Innan ni kan driftsätta applikationen måste ni bygga den. Kommandot sam build samlar in er kod, paketerar eventuella beroenden (till exempel Python-paket) och förbereder allt i ett driftsättningsbart paket.

Kommandot skapar en katalog med namnet .aws-sam som innehåller de bearbetade artefakterna.

sam build

Driftsätta er SAM-applikation

När applikationen har byggts använder ni sam deploy för att skicka den till AWS. Kommandot skapar eller uppdaterar en CloudFormation-stack utifrån er SAM-mall och tillhandahåller alla nödvändiga resurser.

Ni behöver ange ett unikt stacknamn och en S3-bucket för kodartefakter. Argumentet --capabilities CAPABILITY_IAM bekräftar att mallen skapar IAM-roller.

sam deploy --stack-name my-hello-app \
           --s3-bucket your-unique-s3-bucket-name \
           --capabilities CAPABILITY_IAM \
           --region us-east-1

Snabb kontroll: SAM-mallens komponenter

Vilka av följande är viktiga komponenter eller avsnitt i en typisk AWS SAM-mall (template.yaml)?

Besvara frågan i den interaktiva lektionen

Sammanfattning: er SAM-resa börjar

Ni har precis lärt er grunderna i AWS SAM!

SAM förenklar utveckling och driftsättning av serverlösa applikationer med hjälp av en CloudFormation-baserad mall.
Viktiga komponenter är template.yaml med egenskapen Transform och avsnittet Resources.
SAM CLI tillhandahåller kommandon som sam init, sam build och sam deploy för att hantera era applikationer.

Med SAM kan ni effektivt definiera, bygga och driftsätta komplexa serverlösa arkitekturer, vilket gör det till ett kraftfullt verktyg för serverlös utveckling.

Gratis att börja

Lär dig Serverlös utveckling med AWS Lambda med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”AWS Serverless Application Model (SAM)” gratis?

Ja – hela texten till ”AWS Serverless Application Model (SAM)” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Serverlös utveckling med AWS Lambda, kan Ni uppgradera till CoddyKit PRO. Kursen i Serverlös utveckling med AWS Lambda innehåller totalt 4 lektioner.

Vad lär jag mig i ”AWS Serverless Application Model (SAM)”?

Lär dig definiera, utveckla och distribuera serverless-applikationer med AWS SAM, ett ramverk med öppen källkod för utveckling på AWS Ni övar på Serverlös utveckling med AWS Lambda med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Serverlös utveckling med AWS Lambda?

Du behöver inga förkunskaper. Utbildningen i Serverlös utveckling med AWS Lambda på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”AWS Serverless Application Model (SAM)”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Serverlös utveckling med AWS Lambda-lektionen?

Ja. Varje Serverlös utveckling med AWS Lambda-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Serverlös utveckling med AWS Lambda