Mengendalikan Muat Naik Fail Besar dalam Go dengan AWS SStream Like a Pro

Dalam siaran sebelumnya, kami membina perkhidmatan muat naik fail menggunakan Go with local storage dan Amazon S3 untuk storan berasaskan awan. Tetapi bagaimana jika anda perlu mengendalikan fail besar—fikirkan fail video berbilang gigabait atau set data? ? Di situlah perkara boleh menjadi rumit. Anda tidak mahu pelayan anda buntu atau kehabisan memori.

Dalam siaran ini, kami akan meneroka cara mengendalikan muat naik fail besar dengan cekap menggunakan penstriman dan chunking dengan AWS S3. Dengan cara ini, fail yang paling besar pun tidak akan membuatkan apl anda bertekuk lutut.

Ini perkara yang akan kami bincangkan:

1. Mengapa pengendalian fail besar memerlukan penjagaan khas.
2. Menstrim fail besar terus ke S3 dengan penggunaan memori yang minimum.
3. Memotong fail besar dan memasangnya semula pada S3.
4. Amalan terbaik untuk muat naik fail besar dalam persekitaran pengeluaran.

Bersedia untuk mendapatkan fail besar itu terbang ke awan? Mari selami! ?️

---

Langkah 1: Mengapa Mengendalikan Fail Besar Adalah Berbeza

Apabila berurusan dengan muat naik fail yang besar, perkara terakhir yang anda mahu ialah memuatkan keseluruhan fail ke dalam memori. Untuk fail yang lebih kecil, ini bukan masalah besar, tetapi dengan fail yang lebih besar, anda akan mencapai had memori pelayan anda dengan cepat, terutamanya apabila mengendalikan berbilang muat naik serentak.

Penstriman dan chunking ialah teknik utama yang membolehkan anda mengendalikan fail besar ini dengan cekap.

• Penstriman: Muat naik fail ke S3 semasa ia diterima oleh pelayan, bukannya memuatkan keseluruhan fail ke dalam memori.
• Chunking: Pecahkan fail besar kepada bahagian yang lebih kecil (ketulan) dan muat naik setiap ketul secara berasingan. Ini amat berguna untuk menyambung semula muat naik yang gagal atau untuk memuat naik secara selari.

---

Langkah 2: Menstrim Fail Besar Terus ke S3

Kami akan menggunakan AWS SDK untuk menstrim fail daripada permintaan muat naik pengguna terus ke S3, meminimumkan jumlah memori yang kami perlukan pada pelayan.

Mengemas kini Pengendali Muat Naik

Daripada menyimpan keseluruhan fail dalam memori atau pada cakera sebelum memuat naiknya ke S3, kami boleh menggunakan strim untuk menghantar fail dalam masa nyata. Mari ubah suai failUploadHandler sedia ada kami untuk mengendalikan fail besar dengan lebih cekap.

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!")
}

Dalam pendekatan ini, fail distrim terus daripada permintaan ke S3, jadi anda tidak menyimpan keseluruhan fail dalam memori, yang merupakan penyelamat untuk fail besar!

---

Langkah 3: Memotong Fail Besar

Jika anda ingin melangkah lebih jauh, anda boleh memecahkan fail kepada ketulan pada bahagian klien dan memuat naiknya dalam kepingan yang lebih kecil. Ini amat berguna untuk mengendalikan sambungan yang mengelupas atau fail besar, yang mana memulakan semula muat naik dari awal akan menyakitkan.

Contoh Chunking Bahagian Pelanggan

Di sisi pelanggan, pecahkan fail kepada bahagian yang lebih kecil dan muat naik setiap satu secara berasingan. Berikut ialah contoh menggunakan 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!")
}

Pengendalian Bahagian Bahagian Pelayan bagi Ketulan

Di bahagian pelayan, anda boleh menerima ketulan ini dan tambahkannya pada fail yang disimpan di S3:

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,
    });
  }
}

Kaedah ini membolehkan anda memuat naik sebahagian daripada fail secara berasingan dan menggabungkannya dalam awan. Ia sesuai untuk mengendalikan muat naik yang sangat besar di mana kebolehpercayaan adalah kritikal.

---

Langkah 4: Amalan Terbaik untuk Muat Naik Fail Besar

1. Hadkan Saiz Permintaan: Sentiasa tetapkan saiz permintaan maksimum yang munasabah (MaxBytesReader) untuk mengelakkan pengguna daripada mengatasi pelayan anda.

2. Muat Naik Berbilang Bahagian untuk S3: AWS S3 menyokong muat naik berbilang bahagian, yang sesuai untuk fail besar. Anda boleh memuat naik bahagian secara selari dan juga menyambung semula muat naik yang gagal.

3. Muat Naik Fail Selamat: Pastikan anda mengesahkan jenis fail dan menggunakan sambungan selamat (HTTPS) untuk muat naik fail. Bersihkan nama fail untuk mengelakkan serangan lintasan direktori.

4. Penunjuk Kemajuan: Jika anda memecah fail, laksanakan penunjuk kemajuan untuk pengalaman pengguna yang lebih baik, terutamanya untuk fail besar.

---

Membungkus

Mengendalikan muat naik fail yang besar tidak semestinya pening kepala. Dengan menggunakan teknik penstriman dan chunking dengan Go dan S3, anda boleh mengurus dengan cekap walaupun fail terbesar tanpa menyimpan memori pelayan anda. Sama ada anda sedang membina perkhidmatan storan fail, platform video atau apl media-berat, anda kini dilengkapi untuk mengendalikan muat naik besar-besaran seperti seorang profesional. ?

Adakah anda telah melaksanakan muat naik fail yang besar dalam projek anda? Letakkan pengalaman atau petua anda dalam ulasan dan mari teruskan perbualan! ?

Atas ialah kandungan terperinci Mengendalikan Muat Naik Fail Besar dalam Go dengan AWS SStream Like a Pro. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!