Bearbeiten Sie große Datei-Uploads in Go mit AWS SStream wie ein Profi-Golang-php.cn

Handling Large File Uploads in Go with AWS SStream Like a Pro

In einem früheren Beitrag haben wir einen Datei-Upload-Dienst mit Go mit lokalem Speicher und Amazon S3 für cloudbasierten Speicher erstellt. Aber was ist, wenn Sie große Dateien verarbeiten müssen – zum Beispiel Multi-Gigabyte-Videodateien oder Datensätze? ? Da kann es knifflig werden. Sie möchten nicht, dass Ihr Server ins Stocken gerät oder ihm der Speicher ausgeht.

In diesem Beitrag erfahren Sie, wie Sie große Datei-Uploads effizient verarbeiten können mithilfe von Streaming und Chunking mit AWS S3. Auf diese Weise bringen selbst die größten Dateien Ihre App nicht in die Knie.

Folgendes werden wir behandeln:

Warum der Umgang mit großen Dateien besondere Sorgfalt erfordert.
Streamen großer Dateien direkt auf S3 mit minimaler Speichernutzung.
Große Dateien aufteilen und auf S3 wieder zusammensetzen.
Best Practices für das Hochladen großer Dateien in einer Produktionsumgebung.

Sind Sie bereit, diese großen Dateien in die Cloud zu schicken? Lass uns eintauchen! ?️

Schritt 1: Warum der Umgang mit großen Dateien anders ist

Beim Hochladen großer Dateien ist es das Letzte, was Sie wollen, eine ganze Datei in den Speicher zu laden. Bei kleineren Dateien ist das keine große Sache, aber bei größeren Dateien stoßen Sie schnell an die Grenzen des Speichers Ihres Servers, insbesondere wenn Sie mehrere gleichzeitige Uploads verarbeiten.

Streaming und Chunking sind Schlüsseltechniken, mit denen Sie diese großen Dateien effizient verarbeiten können.

Streaming: Laden Sie Dateien auf S3 hoch, während sie vom Server empfangen werden, anstatt die gesamte Datei in den Speicher zu laden.
Chunking: Teilen Sie große Dateien in kleinere Teile (Chunks) auf und laden Sie jeden Chunk einzeln hoch. Dies ist besonders nützlich, um fehlgeschlagene Uploads fortzusetzen oder parallele Uploads durchzuführen.

Schritt 2: Große Dateien direkt auf S3 streamen

Wir verwenden das AWS SDK, um die Datei von der Upload-Anfrage des Benutzers direkt in S3 zu streamen und so den Speicherbedarf auf dem Server zu minimieren.

Aktualisieren des Upload-Handlers

Anstatt die gesamte Datei vor dem Hochladen auf S3 im Speicher oder auf der Festplatte zu speichern, können wir Streams verwenden, um die Datei in Echtzeit zu senden. Ändern wir unseren vorhandenen fileUploadHandler, um große Dateien effizienter zu verarbeiten.

import (
    "fmt"
    "io"
    "net/http"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func fileUploadHandler(w http.ResponseWriter, r *http.Request) {
    // Limit the request size (e.g., 10GB max size)
    r.Body = http.MaxBytesReader(w, r.Body, 10<<30)

    // Parse the multipart form data
    err := r.ParseMultipartForm(10 << 20)
    if err != nil {
        http.Error(w, "File too large", http.StatusRequestEntityTooLarge)
        return
    }

    // Retrieve the file from the form
    file, handler, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "Error retrieving file", http.StatusBadRequest)
        return
    }
    defer file.Close()

    // Set up AWS session
    sess, err := session.NewSession(&aws.Config{
        Region: aws.String("us-west-1"),
    })
    if err != nil {
        http.Error(w, "Error connecting to AWS", http.StatusInternalServerError)
        return
    }

    // Create the S3 client
    s3Client := s3.New(sess)

    // Stream the file directly to S3
    _, err = s3Client.PutObject(&s3.PutObjectInput{
        Bucket: aws.String("your-bucket-name"),
        Key:    aws.String(handler.Filename),
        Body:   file, // Stream the file directly from the request
        ACL:    aws.String("public-read"),
    })
    if err != nil {
        http.Error(w, "Error uploading file to S3", http.StatusInternalServerError)
        return
    }

    fmt.Fprintf(w, "File uploaded successfully to S3!")
}

Nach dem Login kopieren

Bei diesem Ansatz wird die Datei direkt von der Anfrage an S3 gestreamt, sodass Sie nicht die gesamte Datei im Speicher speichern, was bei großen Dateien lebensrettend ist!

Schritt 3: Große Dateien aufteilen

Wenn Sie noch einen Schritt weiter gehen möchten, können Sie Dateien auf der Clientseite in Blöcke aufteilen und sie in kleineren Teilen hochladen. Dies ist besonders nützlich für den Umgang mit instabilen Verbindungen oder großen Dateien, bei denen ein Neustart eines Uploads von Grund auf mühsam wäre.

Beispiel für clientseitiges Chunking

Teilen Sie die Datei auf der Clientseite in kleinere Teile auf und laden Sie diese jeweils einzeln hoch. Hier ist ein Beispiel für die Verwendung von JavaScript:

import (
    "fmt"
    "io"
    "net/http"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func fileUploadHandler(w http.ResponseWriter, r *http.Request) {
    // Limit the request size (e.g., 10GB max size)
    r.Body = http.MaxBytesReader(w, r.Body, 10<<30)

    // Parse the multipart form data
    err := r.ParseMultipartForm(10 << 20)
    if err != nil {
        http.Error(w, "File too large", http.StatusRequestEntityTooLarge)
        return
    }

    // Retrieve the file from the form
    file, handler, err := r.FormFile("file")
    if err != nil {
        http.Error(w, "Error retrieving file", http.StatusBadRequest)
        return
    }
    defer file.Close()

    // Set up AWS session
    sess, err := session.NewSession(&aws.Config{
        Region: aws.String("us-west-1"),
    })
    if err != nil {
        http.Error(w, "Error connecting to AWS", http.StatusInternalServerError)
        return
    }

    // Create the S3 client
    s3Client := s3.New(sess)

    // Stream the file directly to S3
    _, err = s3Client.PutObject(&s3.PutObjectInput{
        Bucket: aws.String("your-bucket-name"),
        Key:    aws.String(handler.Filename),
        Body:   file, // Stream the file directly from the request
        ACL:    aws.String("public-read"),
    })
    if err != nil {
        http.Error(w, "Error uploading file to S3", http.StatusInternalServerError)
        return
    }

    fmt.Fprintf(w, "File uploaded successfully to S3!")
}

Nach dem Login kopieren

Serverseitige Handhabung von Chunks

Auf der Serverseite können Sie diese Chunks empfangen und an die Datei anhängen, die auf S3 gespeichert ist:

async function uploadFileInChunks(file) {
  const chunkSize = 5 * 1024 * 1024; // 5MB per chunk
  const totalChunks = Math.ceil(file.size / chunkSize);

  for (let i = 0; i < totalChunks; i++) {
    const start = i * chunkSize;
    const end = Math.min(file.size, start + chunkSize);
    const chunk = file.slice(start, end);

    const formData = new FormData();
    formData.append("chunk", chunk);
    formData.append("chunkIndex", i);
    formData.append("filename", file.name);

    await fetch("/upload-chunk", {
      method: "POST",
      body: formData,
    });
  }
}

Nach dem Login kopieren

Mit dieser Methode können Sie Teile einer Datei unabhängig hochladen und in der Cloud zusammenführen. Es eignet sich perfekt für die Verarbeitung sehr großer Uploads, bei denen Zuverlässigkeit von entscheidender Bedeutung ist.

Schritt 4: Best Practices für das Hochladen großer Dateien

Anforderungsgrößen begrenzen: Legen Sie immer eine angemessene maximale Anforderungsgröße (MaxBytesReader) fest, um zu verhindern, dass Benutzer Ihren Server überfordern.
Mehrteilige Uploads für S3: AWS S3 unterstützt mehrteilige Uploads, was ideal für große Dateien ist. Sie können Teile parallel hochladen und sogar fehlgeschlagene Uploads fortsetzen.
Sichere Datei-Uploads: Stellen Sie sicher, dass Sie Dateitypen validieren und sichere Verbindungen (HTTPS) für Datei-Uploads verwenden. Bereinigen Sie Dateinamen, um Directory-Traversal-Angriffe zu verhindern.
Fortschrittsanzeigen: Wenn Sie Dateien aufteilen, implementieren Sie eine Fortschrittsanzeige für eine bessere Benutzererfahrung, insbesondere bei großen Dateien.

Zusammenfassung

Das Hochladen großer Dateien muss keine Kopfschmerzen bereiten. Durch den Einsatz von Streaming- und Chunking-Techniken mit Go und S3 können Sie selbst die größten Dateien effizient verwalten, ohne den Speicher Ihres Servers zu belasten. Unabhängig davon, ob Sie einen Dateispeicherdienst, eine Videoplattform oder eine medienintensive App aufbauen, sind Sie jetzt für die Bewältigung umfangreicher Uploads wie ein Profi gerüstet. ?

Haben Sie in Ihren Projekten das Hochladen großer Dateien implementiert? Schreiben Sie Ihre Erfahrungen oder Tipps in die Kommentare und lassen Sie uns die Unterhaltung am Laufen halten! ?

Das obige ist der detaillierte Inhalt vonBearbeiten Sie große Datei-Uploads in Go mit AWS SStream wie ein Profi. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!