Zuletzt aktualisiert: 11. September

Dateien in Node.js nach Amazon S3 exportieren: kompletter Guide

Kevin van Zonneveld

Mitgründer · Amsterdam, Niederlande ·

Der Export von Dateien nach Amazon S3 ist eine gängige Anforderung moderner Webanwendungen. Ob Sie ein System zur Dateispeicherung aufbauen, Backups umsetzen oder Uploads von Nutzern verwalten: Es ist entscheidend zu wissen, wie Sie Dateien mit Node.js effizient nach Amazon S3 exportieren.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie Folgendes haben:

Node.js 20 oder neuer installiert
Ein AWS-Konto mit Zugangsdaten
Grundkenntnisse in JavaScript und Node.js
Ein Projekt, das in Ihrer package.json mit "type": "module" eingerichtet ist

AWS-Zugangsdaten einrichten

Um aus Ihrer Node.js-Anwendung heraus mit Amazon S3 zu interagieren, müssen Sie Ihre AWS-Zugangsdaten konfigurieren. Dafür gibt es mehrere Möglichkeiten:

Umgebungsvariablen: Setzen Sie die folgenden Umgebungsvariablen in Ihrem System oder in der Datei .env:

AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY=YOUR_SECRET_ACCESS_KEY
AWS_REGION=YOUR_AWS_REGION

Gemeinsame Zugangsdaten-Datei: Verwenden Sie die AWS-Datei mit den Zugangsdaten unter ~/.aws/credentials:
```
[default]
aws_access_key_id = YOUR_ACCESS_KEY_ID
aws_secret_access_key = YOUR_SECRET_ACCESS_KEY
```
IAM-Rollen: Wenn Sie Ihre Anwendung auf AWS-Diensten wie EC2 ausführen, können Sie Ihrer Instanz eine IAM-Rolle zuweisen, und das AWS SDK nutzt diese Zugangsdaten automatisch.

Das AWS SDK installieren und verwenden

Wir beginnen mit dem offiziellen AWS SDK for JavaScript (v3). Installieren Sie die nötigen Pakete mit:

npm install @aws-sdk/client-s3 @aws-sdk/lib-storage

Hier ein einfaches Beispiel für das Hochladen einer Datei nach Amazon S3:

import {
  S3Client,
  PutObjectCommand,
  S3ServiceException,
  type PutObjectCommandInput,
} from '@aws-sdk/client-s3'
import { createReadStream } from 'fs'

const s3Client = new S3Client({
  region: 'us-east-1',
})

async function uploadFile(filePath: string, bucketName: string, key: string) {
  try {
    const uploadParams: PutObjectCommandInput = {
      Bucket: bucketName,
      Key: key,
      Body: createReadStream(filePath),
    }

    const command = new PutObjectCommand(uploadParams)
    await s3Client.send(command)
    console.log('Upload completed successfully')
  } catch (err) {
    if (err instanceof S3ServiceException) {
      console.error(`S3 Error: ${err.name} - ${err.message}`)
    } else {
      console.error('Upload failed:', err)
    }
    throw err
  }
}

// Usage
await uploadFile('path/to/file.txt', 'my-bucket', 'file.txt')

Dieses Beispiel verwendet PutObjectCommand, um eine Datei nach S3 hochzuladen. Die Funktion createReadStream streamt die Datei für einen effizienten Upload.

Große Dateien mit Multipart-Upload verarbeiten

Bei großen Dateien empfiehlt es sich, Multipart-Uploads zu verwenden, um Zuverlässigkeit und Performance zu verbessern. Das AWS SDK bietet Hilfsmittel, die diesen Vorgang vereinfachen. Die Klasse Upload aus @aws-sdk/lib-storage übernimmt Multipart-Uploads automatisch:

import { S3Client, S3ServiceException } from '@aws-sdk/client-s3'
import { Upload } from '@aws-sdk/lib-storage'
import { createReadStream } from 'fs'

const s3Client = new S3Client({ region: 'us-east-1' })

async function uploadLargeFile(filePath: string, bucketName: string, key: string) {
  try {
    const upload = new Upload({
      client: s3Client,
      params: {
        Bucket: bucketName,
        Key: key,
        Body: createReadStream(filePath),
      },
    })

    upload.on('httpUploadProgress', (progress) => {
      console.log(`Progress: ${progress.loaded}/${progress.total}`)
    })

    await upload.done()
    console.log('Large file upload completed successfully')
  } catch (err) {
    if (err instanceof S3ServiceException) {
      console.error(`S3 Error: ${err.name} - ${err.message}`)
    } else {
      console.error('Upload failed:', err)
    }
  }
}

// Usage
await uploadLargeFile('path/to/large-file.zip', 'my-bucket', 'large-file.zip')

Bewährte Sicherheitsverfahren

Beim Export von Dateien nach Amazon S3 ist es entscheidend, bewährte Sicherheitsverfahren einzuhalten:

IAM-Rollen verwenden: Setzen Sie beim Deployment auf AWS-Dienste wie EC2 oder ECS IAM-Rollen ein, statt Zugriffsschlüssel fest im Code zu hinterlegen. Das AWS SDK nutzt automatisch HTTPS und lädt Zugangsdaten aus Umgebungsvariablen, gemeinsamen Zugangsdaten-Dateien oder IAM-Rollen, sofern verfügbar.
```
import { S3Client } from '@aws-sdk/client-s3'

const s3Client = new S3Client({
  region: 'us-east-1',
  maxAttempts: 3,
})
```

Zugriff nach dem Least-Privilege-Prinzip umsetzen: Beschränken Sie die Berechtigungen Ihres IAM-Benutzers oder Ihrer IAM-Rolle ausschließlich auf die für die Aufgabe notwendigen.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:PutObject"],
      "Resource": "arn:aws:s3:::your-bucket/*"
    }
  ]
}

Serverseitige Verschlüsselung aktivieren: Schützen Sie Ihre Daten im Ruhezustand, indem Sie die serverseitige Verschlüsselung aktivieren.

const uploadParams: PutObjectCommandInput = {
  Bucket: bucketName,
  Key: key,
  Body: createReadStream(filePath),
  ServerSideEncryption: 'AES256',
}

HTTPS verwenden: Das AWS SDK v3 nutzt für alle API-Aufrufe standardmäßig HTTPS, sodass Daten während der Übertragung verschlüsselt sind.

Fehlerbehandlung und Retries

Die Einstellung maxAttempts des SDK umfasst die erste Anfrage sowie Retries mit Backoff. Ein Stream-Body, der bereits verbraucht wurde, lässt sich jedoch nicht einfach erneut senden. Verwenden Sie für große Dateien bevorzugt den Helper Upload, und öffnen Sie einen Datei-Stream erneut, wenn Ihre Anwendung einen komplett fehlgeschlagenen Upload wiederholt. Vermeiden Sie es, eine enge manuelle Retry-Schleife zusätzlich zur Retry-Policy des SDK zu stapeln.

TypeScript-Unterstützung

Das AWS SDK for JavaScript v3 bietet robuste TypeScript-Unterstützung, die hilft, Fehler bereits während der Entwicklung zu erkennen, und die Autovervollständigung in Ihrer IDE verbessert. Nachfolgend ein einfaches Beispiel, das zeigt, wie Sie beim Hochladen einer Datei Typen definieren:

import { S3Client, PutObjectCommand, type PutObjectCommandInput } from '@aws-sdk/client-s3'
import { createReadStream } from 'fs'

const s3Client = new S3Client({ region: 'us-east-1' })

const uploadParams: PutObjectCommandInput = {
  Bucket: 'my-bucket',
  Key: 'my-key',
  Body: createReadStream('file.txt'),
}

async function uploadFile() {
  try {
    const command = new PutObjectCommand(uploadParams)
    await s3Client.send(command)
    console.log('File uploaded successfully.')
  } catch (error) {
    console.error('Error uploading file:', error)
  }
}

uploadFile()

Dieses Beispiel zeigt, wie Sie mit TypeScript die Struktur Ihrer Parameter definieren und durchsetzen. Das verbessert die Wartbarkeit und deckt mögliche Probleme bereits während der Entwicklung auf.

Fazit

Um Dateien mit Node.js effizient nach Amazon S3 zu exportieren, müssen Sie verstehen, wie Sie mit dem AWS SDK arbeiten, und bewährte Verfahren für Sicherheit und Fehlerbehandlung befolgen. Mit dem AWS SDK und den beschriebenen Strategien bauen Sie in Ihren Node.js-Anwendungen eine robuste Funktion für den Dateiexport auf.

Bei Transloadit konzentrieren wir uns darauf, Dateiverarbeitung und Infrastrukturaufgaben zu vereinfachen. Wenn Sie eine Lösung suchen, die Datei-Uploads und Dateiverarbeitung ohne Aufwand übernimmt, schauen Sie sich gern unsere Services an.