Serverløs backend med AWS Lambda & API Gateway · leksjon

Integrering av Lambda og DynamoDB

Utvikle Lambda-funksjoner som samhandler med DynamoDB for å utføre CRUD-operasjoner og bygge datadrevne serverløse backendløsninger.

Leksjon 3 av 411 trinn

Integrering av Lambda og DynamoDB er en gratis leksjon i Serverløs backend med AWS Lambda & API Gateway på CoddyKit. Dette er leksjon 3 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Serverløs backend med AWS Lambda & API Gateway, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Serverløs backend med AWS Lambda & API Gateway inneholder totalt 4 leksjoner.

Lambda og DynamoDB: Et kraftfullt par

Velkommen til integrasjon av AWS Lambda med DynamoDB! Denne kombinasjonen er grunnleggende for å bygge kraftige, serverløse backend-systemer.

AWS Lambda gir datakraft til å kjøre koden uten at De må administrere servere, mens DynamoDB tilbyr en rask og fleksibel NoSQL-database som skalerer automatisk.

Sammen gjør de det mulig å lage datadrevne applikasjoner som effektivt håndterer create-, read-, update- og delete-operasjoner (CRUD).

Gi Lambda tilgang til DynamoDB

Før Lambda-funksjonen kan samhandle med DynamoDB, trenger den tillatelse. Dette administreres gjennom en IAM Role som er knyttet til Lambda-funksjonen.

IAM-rollen må ha en policy som gir tillatelse til bestemte DynamoDB-handlinger, for eksempel:

dynamodb:PutItem (for å opprette eller oppdatere)
dynamodb:GetItem (for å lese)
dynamodb:UpdateItem (for å endre deler av et element)
dynamodb:DeleteItem (for å fjerne elementer)

Følg alltid prinsippet om minste privilegium: Gi bare de tillatelsene som er nødvendige.

Koble til fra Lambda med Boto3

I en Python-Lambda-funksjon bruker De AWS SDK for Python, Boto3, til å samhandle med DynamoDB. Først må De initialisere en DynamoDB-klient eller -ressurs.

Tilnærmingen boto3.resource('dynamodb') foretrekkes ofte fordi den tilbyr et objektorientert grensesnitt på høyere nivå.

Prøv å kjøre dette eksempelet for å se hvordan klienten initialiseres:

import boto3
import json

def lambda_handler(event, context):
    # Initialize DynamoDB resource
    dynamodb = boto3.resource('dynamodb')
    table_name = 'my-coddykit-table' # Placeholder
    table = dynamodb.Table(table_name)

    print(f"Connected to table: {table_name}")

    return {
        'statusCode': 200,
        'body': json.dumps('DynamoDB client initialized!')
    }

# For local testing/runnable snippet
if __name__ == '__main__':
    print("Running handler locally...")
    lambda_handler({}, {})

Opprette og erstatte elementer (PutItem)

Metoden put_item() brukes til å opprette et nytt element eller erstatte et eksisterende element fullstendig i en DynamoDB-tabell.

Hvis det allerede finnes et element med samme primærnøkkel, overskriver put_item() det fullstendig.
Hvis det ikke finnes et element med denne primærnøkkelen, opprettes et nytt element.

Denne operasjonen er nyttig når De vil sikre at et element finnes med bestemte attributter, eller når De må erstatte alle attributtene.

PutItem i praksis

Her er en Lambda-funksjon som viser hvordan put_item() kan brukes til å legge til eller oppdatere et element. Vi bruker et plassholdernavn for tabellen og elementdetaljer fra hendelsen.

Kjør koden for å se den simulerte opprettelsen av elementet!

import boto3
import json

def lambda_handler(event, context):
    dynamodb = boto3.resource('dynamodb')
    # Use a placeholder table name
    table = dynamodb.Table('my-coddykit-table')

    item_id = event.get('itemId', 'P001')
    item_name = event.get('itemName', 'New Product')

    table.put_item(
        Item={
            'itemId': item_id,
            'itemName': item_name,
            'category': 'Electronics'
        }
    )
    print(f"Added/updated item: {item_id}")
    return {
        'statusCode': 200,
        'body': json.dumps(f'Item {item_id} processed!')
    }

# For local testing/runnable snippet
if __name__ == '__main__':
    mock_event = {'itemId': 'P002', 'itemName': 'Coddy Phone'}
    lambda_handler(mock_event, {})

Lese elementer (GetItem)

For å hente ett enkelt element fra en DynamoDB-tabell bruker De metoden get_item(). Denne operasjonen krever at De oppgir elementets fullstendige primærnøkkel.

Hvis tabellen har en enkel primærnøkkel (bare en Partition Key), oppgir De bare denne verdien. Hvis den har en sammensatt primærnøkkel (Partition Key og Sort Key), må De oppgi begge.

get_item() er svært effektiv for direkte oppslag.

GetItem i praksis

Denne Lambda-funksjonen viser hvordan De kan hente et element ved hjelp av itemId (forutsatt at dette er primærnøkkelen). Responsen vil inneholde elementets attributter hvis elementet blir funnet.

Kjør dette eksempelet for å se hvordan get_item() fungerer.

import boto3
import json

def lambda_handler(event, context):
    dynamodb = boto3.resource('dynamodb')
    # Use a placeholder table name
    table = dynamodb.Table('my-coddykit-table')

    item_id = event.get('itemId', 'P001') # Assume 'itemId' is the primary key

    response = table.get_item(
        Key={'itemId': item_id}
    )
    item = response.get('Item')

    if item:
        print(f"Found item: {item}")
        return {
            'statusCode': 200,
            'body': json.dumps(item)
        }
    else:
        print(f"Item {item_id} not found.")
        return {
            'statusCode': 404,
            'body': json.dumps(f'Item {item_id} not found.')
        }

# For local testing/runnable snippet
if __name__ == '__main__':
    mock_event = {'itemId': 'P002'} # Try to get an item
    lambda_handler(mock_event, {})

Endre deler av et element (UpdateItem)

Metoden update_item() gjør det mulig å endre bestemte attributter i et eksisterende element uten å erstatte hele elementet.

Dette er mer effektivt enn put_item() hvis De bare trenger å endre noen få attributter. Metoden krever et UpdateExpression som angir hvilke attributter som skal endres, og hvordan.

Update expressions kan legge til, angi, fjerne eller slette attributter.

Fjerne elementer (DeleteItem)

For å slette et element fra en DynamoDB-tabell bruker De metoden delete_item(). På samme måte som med get_item() må De oppgi den fullstendige primærnøkkelen til elementet De vil fjerne.

Når et element er slettet, kan det ikke gjenopprettes gjennom denne operasjonen. Vær forsiktig når De bruker delete_item(), særlig i produksjonsmiljøer.

Hurtigsjekk: DynamoDB-operasjoner

De må opprette en ny brukerprofil i DynamoDB-tabellen Users. Hvis det allerede finnes en bruker med samme ID, vil De overskrive den gamle profilen fullstendig med de nye dataene. Hvilken Boto3-metode bør Lambda-funksjonen bruke?

Besvar den i den interaktive leksjonen

Oppsummering: Integrasjon av Lambda og DynamoDB

Godt jobbet! De har lært hvordan AWS Lambda kan integreres med DynamoDB for å bygge datadrevne, serverløse applikasjoner.

Vi gikk gjennom hvor viktige IAM-tillatelser er for sikker tilgang.
De så hvordan Boto3 SDK kan brukes til å koble til fra Python Lambda.
Vi utforsket de viktigste CRUD-operasjonene: put_item() (opprette/erstatte), get_item() (lese), update_item() (endre) og delete_item() (fjerne).

Den kunnskapen er avgjørende for å utvikle robuste, serverløse backend-systemer!

Gratis å komme i gang

Lær deg Serverløs backend med AWS Lambda & API Gateway med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Integrering av Lambda og DynamoDB» gratis?

Ja – hele teksten i «Integrering av Lambda og DynamoDB» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Serverløs backend med AWS Lambda & API Gateway-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Serverløs backend med AWS Lambda & API Gateway inneholder totalt 4 leksjoner.

Hva lærer jeg i «Integrering av Lambda og DynamoDB»?

Utvikle Lambda-funksjoner som samhandler med DynamoDB for å utføre CRUD-operasjoner og bygge datadrevne serverløse backendløsninger. Du øver på Serverløs backend med AWS Lambda & API Gateway med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Serverløs backend med AWS Lambda & API Gateway?

Ingen tidligere erfaring er nødvendig. Serverløs backend med AWS Lambda & API Gateway på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Integrering av Lambda og DynamoDB»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Serverløs backend med AWS Lambda & API Gateway-leksjonen?

Ja. Alle Serverløs backend med AWS Lambda & API Gateway-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Introduksjon til DynamoDB
Utforming av DynamoDB-tabeller
Integrering av Lambda og DynamoDB
Spørringer med sekundærindekser: GSI-er og LSI-er

← Tilbake til Serverløs backend med AWS Lambda & API Gateway