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:
Sind Sie bereit, diese großen Dateien in die Cloud zu schicken? Lass uns eintauchen! ?️
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.
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.
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!")
}
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!
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.
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!")
}
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,
});
}
}
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.
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.
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!
Was bedeutet GPRS-Netzwerk?
Win11 überspringt das Tutorial, um sich beim Microsoft-Konto anzumelden
Was soll ich tun, wenn die chinesische Neustarteinstellung von vscode nicht wirksam wird?
Verwendung der gettickcount-Funktion
Der Unterschied zwischen UCOS und Linux
Soundkartentreiber für HP Notebooks
Warum druckt der Drucker nicht?
Fil-Währungspreis Echtzeitpreis
