Zum Hauptinhalt springen

AWS-Bereitstellung in Cursor: Ein vollständiger Leitfaden

AWS-Bereitstellung in Cursor

Amazon Web Services (AWS) ist die am weitesten verbreitete Cloud-Plattform und bietet Computing, Speicher, Datenbanken und Dutzende von Managed Services auf höherer Ebene. Die Bereitstellung von Anwendungen auf AWS umfasst das Schreiben von Infrastrukturcode, das Verpacken von Funktionen, die Verwaltung von Speicher und die Orchestrierung von Release-Workflows. Cursor ist mit seinem KI-Assistenten und dem reichen Erweiterungs-Ökosystem eine leistungsstarke Umgebung für die AWS-Entwicklung — es kann Lambda-Handler, CloudFormation-Vorlagen und Bereitstellungsskripte aus Natural-Language-Prompts generieren.

Dieser Leitfaden führt Sie durch den vollständigen AWS-Bereitstellungs-Workflow in Cursor: Integration des AWS SDK, Erstellung und Bereitstellung von Lambda-Funktionen, Arbeit mit S3 für Speicher, Erstellung von CloudFormation-Infrastructure-as-Code und Verwendung von KI zur Beschleunigung jedes Schritts.

Einrichtung der AWS-Toolchain in Cursor​

Installation der AWS Toolkit-Erweiterung​

Die Erweiterung AWS Toolkit bringt AWS-Ressourcen-Browsing, lokale Lambda-Ausführung, CloudWatch Logs-Anzeige und SAM-Unterstützung (Serverless Application Model) direkt in Cursor.

  1. Öffnen Sie die Erweiterungsansicht (Ctrl+Shift+X).
  2. Suchen Sie nach „AWS Toolkit".
  3. Klicken Sie auf Install.

Nach der Installation erscheint das AWS-Symbol in der Aktivitätsleiste. Die Erweiterung bietet:

  • Einen Ressourcen-Browser für Lambda, S3, CloudFormation und DynamoDB.
  • Lokale Lambda-Aufrufe mit der SAM CLI.
  • Step Functions-Visualizer.
  • CloudWatch Logs-Streaming.
  • CDK- und SAM-Projekt-Scaffolding.
tipp

AWS Toolkit erfordert, dass AWS-Anmeldeinformationen auf Ihrem Computer konfiguriert sind. Cursor liest dieselbe Anmeldeinformationsdatei (~/.aws/credentials) wie die AWS CLI, sodass alle vorhandenen Profile sofort funktionieren.

Konfiguration von AWS-Anmeldeinformationen​

Erstellen Sie ein Anmeldeinformationsprofil mit der AWS CLI:

npm install -g aws-cli
aws configure

Die interaktive Eingabeaufforderung erfasst:

AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-east-1
Default output format [None]: json

Für Multi-Account-Setups erstellen Sie benannte Profile:

# ~/.aws/credentials
[default]
aws_access_key_id = AKIAIOSFODNN7EXAMPLE
aws_secret_access_key = wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY

[production]
aws_access_key_id = AKIAPRODUCTIONKEY
aws_secret_access_key = productionsecretkeyexample
# ~/.aws/config
[profile production]
region = us-west-2
output = json
warnung

Committen Sie niemals AWS-Anmeldeinformationen in die Versionskontrolle. Fügen Sie .aws/ zu .gitignore hinzu und bevorzugen Sie IAM-Rollen oder kurzlebige STS-Token gegenüber langlebigen Zugriffsschlüsseln. Verwenden Sie für die Produktion aws-vault zur Verwaltung von Anmeldeinformationen mit MFA.

Installation der AWS SAM CLI​

Die SAM-CLI (Serverless Application Model) ermöglicht das Erstellen, lokale Testen und Bereitstellen von Lambda-basierten Anwendungen:

# Windows (mit winget)
winget install AWS.SAM-CLI

# macOS (mit Homebrew)
brew install aws-sam-cli

# Überprüfung
sam --version

Integration des AWS SDK​

Installation des SDK für JavaScript​

Für Node.js-Anwendungen installieren Sie das modulare AWS SDK v3:

npm install @aws-sdk/client-s3 @aws-sdk/client-lambda @aws-sdk/client-dynamodb
tipp

AWS SDK v3 ist modular — Sie installieren nur die Clients, die Sie benötigen, was die Bundle-Größe im Vergleich zum monolithischen v2-SDK drastisch reduziert. Jeder Service ist ein separates Paket unter @aws-sdk/client-*.

Konfiguration des SDK-Clients​

// lib/aws/clients.ts
import { S3Client } from '@aws-sdk/client-s3';
import { LambdaClient } from '@aws-sdk/client-lambda';
import { DynamoDBClient } from '@aws-sdk/client-dynamodb';

const region = process.env.AWS_REGION ?? 'us-east-1';

export const s3Client = new S3Client({ region });
export const lambdaClient = new LambdaClient({ region });
export const dynamoClient = new DynamoDBClient({ region });

Für umgebungsspezifische Anmeldeinformationen (nützlich in CI):

import { fromIni } from '@aws-sdk/credential-providers';

export const s3Client = new S3Client({
  region,
  credentials: fromIni({ profile: 'production' }),
});

Erstellung und Bereitstellung von Lambda-Funktionen​

Scaffolding eines Lambda-Handlers​

Verwenden Sie Cursors KI zum Scaffolding eines Lambda-Handlers. Öffnen Sie Ctrl+K und geben Sie ein:

Create an AWS Lambda handler in TypeScript using the @types/aws-lambda
package. It should accept an API Gateway proxy event, validate the JSON body
against a Zod schema, and return a 200 response with the processed result.
Include structured logging and error handling.

Der generierte Handler:

// src/handlers/createUser.ts
import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
import { z } from 'zod';

const userSchema = z.object({
  name: z.string().min(1),
  email: z.string().email(),
  age: z.number().int().min(0).optional(),
});

export const handler = async (
  event: APIGatewayProxyEvent
): Promise<APIGatewayProxyResult> => {
  console.log('Received event:', JSON.stringify(event, null, 2));

  try {
    const body = JSON.parse(event.body ?? '{}');
    const parsed = userSchema.parse(body);

    const user = {
      id: crypto.randomUUID(),
      ...parsed,
      createdAt: new Date().toISOString(),
    };

    return {
      statusCode: 201,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(user),
    };
  } catch (error) {
    console.error('Error processing request:', error);

    if (error instanceof z.ZodError) {
      return {
        statusCode: 400,
        body: JSON.stringify({ message: 'Validation failed', errors: error.errors }),
      };
    }

    return {
      statusCode: 500,
      body: JSON.stringify({ message: 'Internal server error' }),
    };
  }
};

Lokales Testen mit SAM​

Erstellen Sie eine template.yaml für SAM:

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: User service Lambda

Resources:
  CreateUserFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: dist/handlers
      Handler: createUser.handler
      Runtime: nodejs20.x
      MemorySize: 256
      Timeout: 30
      Events:
        CreateUser:
          Type: Api
          Properties:
            Path: /users
            Method: POST
      Environment:
        Variables:
          TABLE_NAME: !Ref UsersTable

  UsersTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: users
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      KeySchema:
        - AttributeName: id
          KeyType: HASH

Outputs:
  ApiUrl:
    Value: !Sub 'https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/users'

Rufen Sie die Funktion lokal mit einem Beispiel-Event auf:

sam build
sam local invoke CreateUserFunction --event events/createUser.json

Beispiel-Event-Datei:

{
  "httpMethod": "POST",
  "body": "{\"name\":\"Ada Lovelace\",\"email\":\"[email protected]\",\"age\":36}",
  "headers": { "Content-Type": "application/json" }
}
tipp

Die AWS Toolkit-Erweiterung in Cursor fügt Lambda-Funktionen einen „Run Locally"-Befehl hinzu. Klicken Sie mit der rechten Maustaste auf eine Funktion im AWS Explorer-Panel und wählen Sie Invoke on AWS oder Run Locally, um zu testen, ohne den Editor zu verlassen.

Bereitstellung mit SAM​

# Erste Bereitstellung (geführt)
sam deploy --guided

# Nachfolgende Bereitstellungen
sam deploy --stack-name user-service --capabilities CAPABILITY_IAM

Die geführte Eingabeaufforderung erfasst:

Stack Name [sam-app]: user-service
AWS Region [us-east-1]: us-east-1
Confirm changes before deploy [Y/n]: Y
Allow SAM CLI IAM role creation [Y/n]: Y
Disable rollback [Y/n]: n
Save arguments to configuration file [Y/n]: Y
warnung

SAM-Bereitstellungen erstellen automatisch IAM-Rollen. Überprüfen Sie die Changeset-Zusammenfassung vor der Bestätigung sorgfältig — eine falsch konfigurierte Rolle kann zu weitreichende Berechtigungen vergeben, die das Least-Privilege-Prinzip in der Produktion verletzen.

Arbeit mit S3 für Speicher​

Dateien auf S3 hochladen​

// src/storage/upload.ts
import { s3Client } from '../aws/clients';
import { PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
import { getSignedUrl } from '@aws-sdk/s3-request-presigner';

const BUCKET = process.env.UPLOAD_BUCKET ?? 'my-app-uploads';

export async function uploadFile(
  key: string,
  body: Buffer,
  contentType: string
): Promise<string> {
  const command = new PutObjectCommand({
    Bucket: BUCKET,
    Key: key,
    Body: body,
    ContentType: contentType,
  });

  await s3Client.send(command);
  return `s3://${BUCKET}/${key}`;
}

export async function getDownloadUrl(key: string, expiresIn = 3600): Promise<string> {
  const command = new GetObjectCommand({ Bucket: BUCKET, Key: key });
  return getSignedUrl(s3Client, command, { expiresIn });
}

Streaming großer Dateien​

Für große Uploads verwenden Sie Multipart-Upload:

// src/storage/multipart.ts
import { s3Client } from '../aws/clients';
import {
  CreateMultipartUploadCommand,
  UploadPartCommand,
  CompleteMultipartUploadCommand,
} from '@aws-sdk/client-s3';
import { createReadStream } from 'fs';

const BUCKET = process.env.UPLOAD_BUCKET ?? 'my-app-uploads';

export async function uploadLargeFile(key: string, filePath: string): Promise<void> {
  const create = await s3Client.send(
    new CreateMultipartUploadCommand({ Bucket: BUCKET, Key: key })
  );
  const uploadId = create.UploadId!;

  const partSize = 5 * 1024 * 1024; // 5 MB minimum
  const stream = createReadStream(filePath, { highWaterMark: partSize });
  const parts: { ETag: string; PartNumber: number }[] = [];
  let partNumber = 1;

  for await (const chunk of stream) {
    const upload = await s3Client.send(
      new UploadPartCommand({
        Bucket: BUCKET,
        Key: key,
        UploadId: uploadId,
        PartNumber: partNumber,
        Body: chunk,
      })
    );
    parts.push({ ETag: upload.ETag!, PartNumber: partNumber });
    partNumber++;
  }

  await s3Client.send(
    new CompleteMultipartUploadCommand({
      Bucket: BUCKET,
      Key: key,
      UploadId: uploadId,
      MultipartUpload: { Parts: parts },
    })
  );
}
tipp

Verwenden Sie Cursors KI zum Generieren von Pre-signed-URL-Flows. Prompt: „Erstelle eine Lambda-Funktion, die eine pre-signed S3-Upload-URL generiert, die Dateierweiterung validiert und Metadaten in DynamoDB speichert."

CloudFormation Infrastructure as Code​

Schreiben von CloudFormation-Vorlagen​

CloudFormation ermöglicht es Ihnen, Ihre gesamte Infrastruktur in deklarativem YAML oder JSON zu definieren. Cursors KI ist hervorragend darin, Vorlagen aus Beschreibungen zu generieren.

Beispielvorlage für einen Web-Anwendungs-Stack:

# templates/webapp.yaml
AWSTemplateFormatVersion: '2010-09-09'
Description: Production web application stack

Parameters:
  Environment:
    Type: String
    Default: production
    AllowedValues: [staging, production]

  DomainName:
    Type: String
    Description: Custom domain name

Resources:
  ApplicationBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub '${AWS::StackName}-app-${Environment}'
      VersioningConfiguration:
        Status: Enabled
      LifecycleConfiguration:
        Rules:
          - Id: ExpireOldVersions
            Status: Enabled
            NoncurrentVersionExpirationInDays: 90
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true

  CloudFrontDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        Enabled: true
        DefaultRootObject: index.html
        Origins:
          - DomainName: !GetAtt ApplicationBucket.RegionalDomainName
            Id: S3Origin
            S3OriginConfig: {}
        DefaultCacheBehavior:
          TargetOriginId: S3Origin
          ViewerProtocolPolicy: redirect-to-https
          AllowedMethods: [GET, HEAD]
          CachedMethods: [GET, HEAD]
          ForwardedValues:
            QueryString: false
        PriceClass: PriceClass_100
        ViewerCertificate:
          CloudFrontDefaultCertificate: true

  ApiGateway:
    Type: AWS::ApiGateway::RestApi
    Properties:
      Name: !Sub '${AWS::StackName}-api'
      EndpointConfiguration:
        Types: [REGIONAL]

Outputs:
  WebsiteUrl:
    Value: !Sub 'https://${CloudFrontDistribution.DomainName}'
    Description: URL of the deployed website

Bereitstellung von CloudFormation-Stacks​

# Vorlage validieren
aws cloudformation validate-template --template-body file://templates/webapp.yaml

# Stack erstellen
aws cloudformation create-stack \
  --stack-name webapp-production \
  --template-body file://templates/webapp.yaml \
  --parameters ParameterKey=Environment,ParameterValue=production \
               ParameterKey=DomainName,ParameterValue=app.example.com \
  --capabilities CAPABILITY_NAMED_IAM

# Bereitstellung überwachen
aws cloudformation describe-stacks --stack-name webapp-production

# Stack aktualisieren
aws cloudformation update-stack \
  --stack-name webapp-production \
  --template-body file://templates/webapp.yaml \
  --parameters ParameterKey=Environment,ParameterValue=production \
               ParameterKey=DomainName,ParameterValue=app.example.com \
  --capabilities CAPABILITY_NAMED_IAM
warnung

CloudFormation-Aktualisierungen können Ressourcen ersetzen. Ressourcen mit UpdateReplacePolicy: Retain überleben die Ersetzung, aber alle Ressourcen ohne diese Richtlinie werden beim Löschen des Stacks gelöscht. Überprüfen Sie immer das Change Set vor dem Anwenden:

aws cloudformation create-change-set --stack-name webapp-production --change-set-name my-change --template-body file://templates/webapp.yaml
aws cloudformation describe-change-set --stack-name webapp-production --change-set-name my-change

Verwendung von CDK als Alternative​

Das AWS Cloud Development Kit (CDK) ermöglicht es Ihnen, Infrastruktur in TypeScript zu schreiben. Cursors KI generiert CDK-Konstrukte auf natürliche Weise.

// lib/webapp-stack.ts
import * as cdk from 'aws-cdk-lib';
import * as s3 from 'aws-cdk-lib/aws-s3';
import * as cloudfront from 'aws-cdk-lib/aws-cloudfront';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
import { Construct } from 'constructs';

export class WebappStack extends cdk.Stack {
  constructor(scope: Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const bucket = new s3.Bucket(this, 'AppBucket', {
      versioned: true,
      encryption: s3.BucketEncryption.S3_MANAGED,
      blockPublicAccess: s3.BlockPublicAccess.BLOCK_ALL,
      lifecycleRules: [
        { id: 'ExpireOldVersions', noncurrentVersionExpiration: cdk.Duration.days(90) },
      ],
    });

    const distribution = new cloudfront.CloudFrontWebDistribution(this, 'Distribution', {
      originConfigs: {
        s3: {
          s3OriginSource: { s3BucketSource: bucket },
          behaviors: [{ isDefaultBehavior: true }],
        },
      },
    });

    const api = new apigateway.LambdaRestApi(this, 'Api', {
      handler: new lambda.Function(this, 'Handler', {
        runtime: lambda.Runtime.NODEJS_20_X,
        code: lambda.Code.fromAsset('dist/handlers'),
        handler: 'index.handler',
      }),
    });

    new cdk.CfnOutput(this, 'WebsiteUrl', {
      value: `https://${distribution.distributionDomainName}`,
    });
  }
}

Bereitstellung mit CDK:

cdk synth
cdk deploy

KI-gestützte Infrastruktur-Generierung​

Generieren von Vorlagen aus Prompts​

Cursor excelt darin, Natural-Language-Beschreibungen in Infrastrukturcode umzuwandeln. Öffnen Sie einen Chat (Ctrl+Shift+P → „Cursor: New Chat") und beschreiben Sie, was Sie benötigen:

Generate a CloudFormation template for a serverless blog API. It should
include: an API Gateway with /posts and /posts/{id} routes, Lambda
functions for CRUD operations, a DynamoDB table with a GSI on the
authorId attribute, and an S3 bucket for media uploads with CORS
configured. Use least-privilege IAM roles.

Cursor erzeugt eine vollständige YAML-Vorlage. Überprüfen Sie die IAM-Richtlinien sorgfältig und verfeinern Sie, indem Sie nach strengeren Berechtigungen oder zusätzlichen Ressourcen fragen.

tipp

Wenn Sie IAM-Richtlinien mit KI generieren, fordern Sie immer explizit „Least-Privilege"-Richtlinien an. Vage Prompts tendieren dazu, Richtlinien mit Action: '*' auf Resource: '*' zu erzeugen, was ein ernstes Sicherheitsrisiko darstellt.

Generieren von CDK-Konstrukten​

Für TypeScript-native Teams weisen Sie Cursor an, CDK-Code anstelle von rohem CloudFormation zu generieren:

Create a CDK construct called ServerlessApi that provisions an API
Gateway, three Lambda functions (get, create, delete), and a DynamoDB
table with on-demand billing. Expose the API URL as a construct property.

Refactoring von Infrastruktur​

Cursor kann bestehende Infrastruktur refactoren. Häufige Transformationen:

  • Konvertierung von rohem CloudFormation-YAML in CDK-TypeScript.
  • Aufteilung einer monolithischen Vorlage in verschachtelte Stacks.
  • Hinzufügen von DeletionPolicy: Retain zu zustandsbehafteten Ressourcen für die Drift-Erkennung.
  • Ersetzung von Inline-IAM-Richtlinien durch Managed Policies.

Bereitstellungs-Workflows und CI-Integration​

GitHub Actions-Bereitstellung​

Erstellen Sie .github/workflows/deploy.yml für die Bereitstellung bei Push auf main:

name: Deploy to AWS

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read

    steps:
      - uses: actions/checkout@v4

      - name: Configure AWS credentials
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/github-actions-deploy
          aws-region: us-east-1

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20
          cache: npm

      - name: Install dependencies
        run: npm ci

      - name: Build
        run: npm run build

      - name: Run tests
        run: npm test

      - name: SAM build
        run: sam build

      - name: Deploy
        run: sam deploy --stack-name ${{ vars.STACK_NAME }} --no-confirm-changeset --no-fail-on-empty-changeset --capabilities CAPABILITY_IAM
warnung

Speichern Sie niemals AWS-Zugriffsschlüssel als GitHub Actions-Secrets. Verwenden Sie OIDC-Föderation mit role-to-assume, wie oben gezeigt. Dies eliminiert langlebige Anmeldeinformationen und entspricht den AWS-Sicherheits-Best Practices.

Blue-Green-Bereitstellungen mit Lambda-Aliasen​

Lambda-Aliase ermöglichen Traffic-Shifting zwischen Versionen für Blue-Green-Bereitstellungen:

# Neue Version veröffentlichen
aws lambda publish-version --function-name user-service

# Alias aktualisieren, um 10% auf die neue Version zu leiten
aws lambda update-alias \
  --function-name user-service \
  --name production \
  --routing-config AdditionalVersionWeights='{"2":0.1}'

# Nach Validierung auf 100% hochstufen
aws lambda update-alias \
  --function-name user-service \
  --name production \
  --function-version 2 \
  --routing-config AdditionalVersionWeights='{}'

Überwachung und Debugging​

CloudWatch Logs-Streaming​

AWS Toolkit streamt CloudWatch Logs in Cursor. Im AWS Explorer:

  1. Erweitern Sie CloudWatch Logs.
  2. Wählen Sie eine Protokollgruppe aus (z. B. /aws/lambda/user-service).
  3. Klicken Sie mit der rechten Maustaste und wählen Sie View Log Stream.

Protokolle erscheinen in einem schreibgeschützten Editor-Tab mit Live-Updates.

tipp

Verwenden Sie strukturierte Protokollierung in Ihren Lambda-Handlern — JSON-formatierte Protokolle sind in CloudWatch Logs Insights abfragbar:

console.log(JSON.stringify({
  level: 'info',
  message: 'User created',
  userId: user.id,
  timestamp: new Date().toISOString(),
}));

X-Ray-Tracing​

Aktivieren Sie X-Ray-Tracing auf Lambda, um Request-Flows zu visualisieren:

Resources:
  CreateUserFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: dist/handlers
      Handler: createUser.handler
      Runtime: nodejs20.x
      Tracing: Active

Installieren Sie das Tracing-SDK:

npm install @aws-lambda-powertools/tracer
// src/handlers/createUser.ts
import { Tracer } from '@aws-lambda-powertools/tracer';
import { captureLambdaHandler } from '@aws-lambda-powertools/tracer/middleware';

const tracer = new Tracer({ serviceName: 'user-service' });

export const handler = captureLambdaHandler(tracer)(
  async (event) => {
    // ... handler logic
  }
);

Best Practices für die AWS-Entwicklung in Cursor​

Projektstruktur​

project/
  ├── src/
  │   ├── handlers/        # Lambda-Einstiegspunkte
  │   ├── lib/             # Gemeinsame Geschäftslogik
  │   ├── aws/             # SDK-Client-Konfiguration
  │   └── storage/         # S3- und Speicher-Dienstprogramme
  ├── templates/           # CloudFormation YAML
  ├── lib/                 # CDK-Konstrukte (wenn CDK verwendet)
  ├── events/              # Beispiel-Lambda-Event-Payloads
  ├── tests/
  ├── template.yaml        # SAM-Vorlage
  └── samconfig.toml       # SAM-Konfiguration

Umgebungsverwaltung​

Verwenden Sie separate AWS-Konten für Entwicklung, Staging und Produktion. Verwalten Sie diese mit Profilen:

export AWS_PROFILE=production
sam deploy --stack-name webapp-production

Kostenoptimierung​

  • Verwenden Sie PAY_PER_REQUEST-Abrechnung für DynamoDB-Tabellen mit unvorhersehbarem Traffic.
  • Konfigurieren Sie S3-Lebenszyklusregeln, um selten zugegriffene Objekte in billigere Speicherklassen zu überführen.
  • Aktivieren Sie Lambda Provisioned Concurrency nur für latenzkritische Funktionen.
tipp

Cursors KI kann Ihre CloudFormation-Vorlagen auf Kosten prüfen. Prompt: „Überprüfen Sie diese Vorlage und schlagen Sie Kostenoptimierungen vor. Identifizieren Sie überdimensionierte Ressourcen und empfehlen Sie Right-Sizing."

Sicherheits-Checkliste​

  • Aktivieren Sie S3 Block Public Access auf allen Buckets.
  • Verwenden Sie KMS-Verschlüsselung für sensible Daten im Ruhezustand.
  • Wenden Sie Least-Privilege-IAM-Richtlinien an — verwenden Sie niemals Action: '*'.
  • Aktivieren Sie CloudTrail für Audit-Protokollierung.
  • Rotieren Sie Zugriffsschlüssel alle 90 Tage oder eliminieren Sie diese mit IAM-Rollen.

Häufige Fallstricke und wie man sie vermeidet​

Hardcodierte ARNs und Regionen​

Vermeiden Sie es, ARNs direkt in Code einzubetten — sie funktionieren nicht konten- und regionsübergreifend:

// FALSCH
const tableArn = 'arn:aws:dynamodb:us-east-1:123456789012:table/users';

// RICHTIG — über Umgebungsvariable übergeben
const tableName = process.env.TABLE_NAME!;

Vergessene IAM-Berechtigungen​

Ein häufiger Bereitstellungsfehler ist eine Lambda-Funktion, der die Berechtigung für den Zugriff auf eine Ressource fehlt. Die Funktion wird erfolgreich bereitgestellt, scheitert aber zur Laufzeit mit einem AccessDenied-Fehler. Testen Sie immer lokal mit SAM und überprüfen Sie CloudWatch Logs nach der Bereitstellung.

Ignorieren von Cold Starts​

Lambda-Cold-Starts können Latenz zur ersten Anfrage nach Leerlauf hinzufügen. Mildern Sie durch:

  • Verwendung kleinerer Bereitstellungspakete.
  • Bereitstellung von Concurrency für latenzempfindliche Funktionen.
  • Beibehaltung des Initialisierungscodes außerhalb der Handler-Funktion.
warnung

Provisioned Concurrency verursacht Kosten, auch wenn keine Anfragen bedient werden. Überwachen Sie die Nutzung sorgfältig und deaktivieren Sie sie für Entwicklungsumgebungen.

Zusammenfassung​

Cursor vereinfacht die AWS-Bereitstellung durch die Kombination von AWS Toolkit für Ressourcenverwaltung, SAM CLI für lokale Tests, CloudFormation und CDK für Infrastructure as Code sowie dem KI-Assistenten zum Generieren von Handlern, Vorlagen und Bereitstellungs-Workflows. Beginnen Sie mit der Installation von AWS Toolkit und SAM CLI, scaffolden Sie eine Lambda-Funktion und lassen Sie Cursors KI Ihre Infrastruktur-Erstellung beschleunigen. Überprüfen Sie immer IAM-Richtlinien auf Least Privilege, verwenden Sie OIDC für CI-Bereitstellungen und überwachen Sie mit CloudWatch Logs und X-Ray, um Ihre AWS-Anwendungen sicher und beobachtbar zu halten.