Serverløs udvikling med AWS Lambda · Lektion

Integration med DynamoDB

Forbind Lambda-funktioner med Amazon DynamoDB, en fuldt administreret NoSQL-database, for at opnå højtydende og skalerbar datalagring og -hentning i serverless-applikationer.

Lektion 1 af 411 trin

Integration med DynamoDB er en gratis Serverløs udvikling med AWS Lambda-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Serverløs udvikling med AWS Lambda, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Serverløs udvikling med AWS Lambda-kurset indeholder 4 lektioner i alt.

Lambda møder DynamoDB

Velkommen! I denne lektion forbinder vi styrken ved serverløse AWS Lambda med Amazon DynamoDB, en lynhurtig og fleksibel NoSQL-database.

Denne kombination er perfekt til at bygge skalerbare applikationer med høj ydeevne uden at administrere servere eller databaseinfrastruktur.

DynamoDB: NoSQL i korte træk

Amazon DynamoDB er en fuldt administreret, serverløs NoSQL-database. I modsætning til traditionelle SQL-databaser bruger den en nøgle-værdi- og dokumentdatamodel.

Tabeller: Ligner SQL-tabeller, men indeholder elementer.
Elementer: Svarer til rækker i SQL, men kan have forskellige attributter.
Attributter: Svarer til kolonner, men er fleksible (intet fast skema).
Primærnøgle: Identificerer hvert element entydigt. Den kan være en simpel partitionsnøgle eller en sammensat partitionsnøgle + sorteringsnøgle.

Konfiguration af din DynamoDB-tabel

Før Lambda kan interagere med DynamoDB, skal du have en tabel. Du kan nemt oprette en i AWS Management Console.

Under oprettelsen definerer du en primærnøgle. Det er almindeligt at bruge attributten id som partitionsnøgle til simple opslag.

Giv Lambda adgang til DynamoDB

For at din Lambda-funktion kan kommunikere med DynamoDB, skal den have tilladelse. Det administreres via en IAM-rolle, der er knyttet til din Lambda-funktion.

Du skal give politikker som dynamodb:PutItem, dynamodb:GetItem osv. adgang til bestemte tabeller for at opnå sikker og detaljeret adgangskontrol. I undervisningsøjemed kan AmazonDynamoDBFullAccess bruges i starten, men vælg altid mindst mulige privilegier i produktion.

Skrivning af data: PutItem-handlingen

Handlingen PutItem bruges til at føje et nyt element til en tabel eller erstatte et eksisterende element, hvis der allerede findes et element med samme primærnøgle.

Prøv at køre dette eksempel for at se, hvordan du tilføjer et element. Vi bruger en simuleret AWS SDK til lokal kørsel.

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      put: (params) => ({
        promise: () => {
          console.log("MOCK: Put item to table '" + params.TableName + "':", params.Item);
          return Promise.resolve({ success: true, item: params.Item });
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Item: {
      id: event.userId,
      name: event.userName,
      email: event.userEmail
    }
  };

  try {
    const data = await ddb.put(params).promise();
    console.log("Operation successful (mock):", data);
    return { statusCode: 200, body: JSON.stringify(data) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated PutItem operation...");
  const testEvent = {
    userId: "user123",
    userName: "Alice",
    userEmail: "alice@example.com"
  };
  await handler(testEvent);
}

main();

Forstå PutItem-koden

I eksemplet bruger vi DynamoDB.DocumentClient() til at forenkle interaktionen med DynamoDB, fordi den håndterer datatyper automatisk.

TableName: Navnet på din DynamoDB-tabel.
Item: Et JavaScript-objekt, der repræsenterer de data, du vil gemme. Hvert nøgle-værdi-par er en attribut.
promise(): Bruges til at håndtere den asynkrone karakter af AWS SDK-kald.

Læsning af data: GetItem-handlingen

Hvis du vil hente et enkelt element fra din tabel, bruger du handlingen GetItem. Du skal angive hele primærnøglen for det element, du vil hente.

Kør denne kode for at se, hvordan du henter et element.

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      get: (params) => ({
        promise: () => {
          console.log("MOCK: Get item from table '" + params.TableName + "' with Key:", params.Key);
          // Simulate finding an item with id 'user123'
          if (params.Key.id === "user123") {
            return Promise.resolve({ Item: { id: "user123", name: "Alice", email: "alice@example.com" } });
          }
          return Promise.resolve({ Item: null }); // Item not found
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Key: {
      id: event.userId // The primary key to retrieve
    }
  };

  try {
    const data = await ddb.get(params).promise();
    console.log("Retrieved item (mock):", data.Item);
    return { statusCode: 200, body: JSON.stringify(data.Item) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated GetItem operation...");
  const testEvent = {
    userId: "user123" // ID of the item to retrieve
  };
  await handler(testEvent);
}

main();

Opdatering af data: UpdateItem-handlingen

Handlingen UpdateItem ændrer eksisterende attributter for et element eller tilføjer nye attributter, hvis de ikke findes. Den er mere effektiv end først at læse og ændre elementet og derefter gemme hele elementet igen.

Dette eksempel opdaterer email for en eksisterende bruger.

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      update: (params) => ({
        promise: () => {
          console.log("MOCK: Update item in table '" + params.TableName + "' with Key:", params.Key);
          console.log("MOCK: Update Expression:", params.UpdateExpression, "Values:", params.ExpressionAttributeValues);
          return Promise.resolve({ Attributes: { id: params.Key.id, email: "updated@example.com" } });
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Key: {
      id: event.userId // Primary key of the item to update
    },
    UpdateExpression: "set email = :e",
    ExpressionAttributeValues: {
      ":e": event.newEmail
    },
    ReturnValues: "UPDATED_NEW" // Return the new values of updated attributes
  };

  try {
    const data = await ddb.update(params).promise();
    console.log("Updated item (mock):", data.Attributes);
    return { statusCode: 200, body: JSON.stringify(data.Attributes) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated UpdateItem operation...");
  const testEvent = {
    userId: "user123",
    newEmail: "alice.new@example.com"
  };
  await handler(testEvent);
}

main();

Sletning af data: DeleteItem-handlingen

Når du ikke længere har brug for et element, kan du fjerne det ved hjælp af handlingen DeleteItem. Ligesom med GetItem skal du angive hele primærnøglen for det element, der skal slettes.

Vær forsigtig med sletninger, da de er permanente!

// MOCK AWS SDK for local runnable example
const mockDynamoDB = {
  DocumentClient: function() {
    return {
      delete: (params) => ({
        promise: () => {
          console.log("MOCK: Delete item from table '" + params.TableName + "' with Key:", params.Key);
          return Promise.resolve({ success: true });
        }
      })
    };
  }
};

// Simulate the Lambda handler function
async function handler(event) {
  const ddb = new mockDynamoDB.DocumentClient();

  const params = {
    TableName: "MyUsersTable", // Replace with your table name
    Key: {
      id: event.userId // Primary key of the item to delete
    }
  };

  try {
    const data = await ddb.delete(params).promise();
    console.log("Item deleted successfully (mock).");
    return { statusCode: 200, body: JSON.stringify(data) };
  } catch (err) {
    console.error("Operation failed (mock):", err);
    return { statusCode: 500, body: JSON.stringify(err) };
  }
}

// Entry point for CoddyKit's runnable environment
async function main() {
  console.log("Running simulated DeleteItem operation...");
  const testEvent = {
    userId: "user123" // ID of the item to delete
  };
  await handler(testEvent);
}

main();

Hurtigt tjek: DynamoDB-handlinger

Du har lært om grundlæggende DynamoDB-handlinger. Lad os teste din forståelse!

Besvar den i den interaktive lektion

Opsummering: Lambda + DynamoDB

Flot arbejde! Du har lært at integrere AWS Lambda med Amazon DynamoDB for at bygge effektive serverløse applikationer.

DynamoDB leverer en skalerbar NoSQL-database.
Lambda-funktioner skal have IAM-tilladelser for at interagere med DynamoDB-tabeller.
Du kan udføre almindelige handlinger som PutItem (opret/erstat), GetItem (læs), UpdateItem (rediger) og DeleteItem (fjern).

Denne integration er grundlæggende for at bygge dynamiske, hændelsesdrevne serverløse backend-systemer!

Gratis at komme i gang

Lær Serverløs udvikling med AWS Lambda med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 12
Lektioner: 48

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Integration med DynamoDB” gratis?

Ja — hele teksten til “Integration med DynamoDB” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Serverløs udvikling med AWS Lambda-kurset, skal du opgradere til CoddyKit PRO. Serverløs udvikling med AWS Lambda-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Integration med DynamoDB”?

Forbind Lambda-funktioner med Amazon DynamoDB, en fuldt administreret NoSQL-database, for at opnå højtydende og skalerbar datalagring og -hentning i serverless-applikationer. Du øver dig i Serverløs udvikling med AWS Lambda med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Serverløs udvikling med AWS Lambda?

Der kræves ingen tidligere erfaring. Serverløs udvikling med AWS Lambda på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Integration med DynamoDB”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Serverløs udvikling med AWS Lambda-lektion?

Ja. Alle Serverløs udvikling med AWS Lambda-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Serverløs udvikling med AWS Lambda