Serverlös utveckling med AWS Lambda · Lektion

Integrering med DynamoDB

Anslut Lambda-funktioner till Amazon DynamoDB, en fullständigt hanterad NoSQL-databas, för högpresterande och skalbar lagring och hämtning av data i serverless-applikationer

Lektion 1 av 411 steg

Integrering med DynamoDB ä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.

Lambda möter DynamoDB

Välkommen! I den här lektionen kopplar vi ihop kraften i serverlösa AWS Lambda med Amazon DynamoDB, en mycket snabb och flexibel NoSQL-databas.

Denna kombination passar perfekt för att bygga skalbara applikationer med hög prestanda utan att hantera servrar eller databas infrastruktur.

DynamoDB: NoSQL i korthet

Amazon DynamoDB är en fullständigt hanterad, serverlös NoSQL-databas. Till skillnad från traditionella SQL-databaser använder den en nyckel-värde- och dokumentdatamodell.

Tabeller: Liknar SQL-tabeller, men innehåller items.
Items: Liknar rader i SQL, men kan ha olika attribut.
Attribut: Liknar kolumner, men är flexibla (inget fast schema).
Primärnyckel: Identifierar varje item unikt. Kan vara en enkel partitionsnyckel eller en kombination av partitionsnyckel och sorteringsnyckel.

Konfigurera din DynamoDB-tabell

Innan Lambda kan kommunicera med DynamoDB behöver du en tabell. Du kan enkelt skapa en i AWS Management Console.

När du skapar tabellen definierar du en Primary Key. Till exempel är ett id-attribut som partitionsnyckel vanligt vid enkla sökningar.

Ge Lambda åtkomst till DynamoDB

För att din Lambda-funktion ska kunna kommunicera med DynamoDB behöver den behörighet. Detta hanteras via en IAM Role som är kopplad till din Lambda-funktion.

Du måste ge behörigheter som dynamodb:PutItem, dynamodb:GetItem och så vidare till specifika tabeller för säker och detaljerad åtkomst. För enkelhetens skull i utbildningssyfte kan AmazonDynamoDBFullAccess användas inledningsvis, men föredra alltid minsta privilegium i produktion.

Skriva data: PutItem-åtgärden

Åtgärden PutItem används för att lägga till ett nytt item i en tabell eller ersätta ett befintligt item om ett item med samma primärnyckel redan finns.

Prova att köra det här exemplet för att se hur du lägger till ett item. Vi använder ett simulerat AWS SDK för lokal körning.

// 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();

Förstå PutItem-koden

I exemplet använder vi DynamoDB.DocumentClient() för att förenkla kommunikationen med DynamoDB, eftersom den hanterar datatyper automatiskt.

TableName: Namnet på din DynamoDB-tabell.
Item: Ett JavaScript-objekt som representerar de data du vill lagra. Varje nyckel-värde-par är ett attribut.
promise(): Används för att hantera AWS SDK-anropens asynkrona natur.

Läsa data: GetItem-åtgärden

För att hämta ett enskilt item från tabellen använder du åtgärden GetItem. Du måste ange hela Primary Key för det item du vill hämta.

Kör den här koden för att se hur du hämtar ett item.

// 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();

Uppdatera data: UpdateItem-åtgärden

Åtgärden UpdateItem ändrar befintliga attribut i ett item eller lägger till nya attribut om de inte finns. Den är effektivare än att läsa, ändra och sedan skriva tillbaka hela itemet.

Det här exemplet uppdaterar email för en befintlig användare.

// 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();

Ta bort data: DeleteItem-åtgärden

När du inte längre behöver ett item kan du ta bort det med åtgärden DeleteItem. Precis som med GetItem måste du ange hela primärnyckeln för det item som ska tas bort.

Var försiktig vid borttagningar, eftersom de är permanenta!

// 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();

Snabbtest: DynamoDB-åtgärder

Du har lärt dig grunderna i DynamoDB-åtgärder. Nu testar vi dina kunskaper!

Besvara frågan i den interaktiva lektionen

Sammanfattning: Lambda + DynamoDB

Bra jobbat! Du har lärt dig att integrera AWS Lambda med Amazon DynamoDB för kraftfulla serverlösa applikationer.

DynamoDB tillhandahåller en skalbar NoSQL-databas.
Lambda-funktioner behöver IAM-behörigheter för att kommunicera med DynamoDB-tabeller.
Du kan utföra vanliga åtgärder som PutItem (skapa/ersätta), GetItem (läsa), UpdateItem (ändra) och DeleteItem (ta bort).

Denna integration är grundläggande för att bygga dynamiska, händelsestyrda serverlösa backend-system!

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 ”Integrering med DynamoDB” gratis?

Ja – hela texten till ”Integrering med DynamoDB” 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 ”Integrering med DynamoDB”?

Anslut Lambda-funktioner till Amazon DynamoDB, en fullständigt hanterad NoSQL-databas, för högpresterande och skalbar lagring och hämtning av data i serverless-applikationer 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 ”Integrering med DynamoDB”?

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