Menggunakan Sistem Fail Elastik AWS (EFS) dalam Go: Panduan Lengkap

Dengan aplikasi meluas teknologi pengkomputeran awan dan aplikasi kontena, semakin banyak perusahaan mula memindahkan aplikasi daripada pelayan fizikal tradisional kepada persekitaran awan untuk penggunaan dan operasi. Menggunakan sistem storan berprestasi tinggi dalam persekitaran awan ialah isu yang sangat penting, dan AWS Elastic File System (EFS) ialah sistem fail teragih yang berkuasa yang boleh menyediakan ketersediaan tinggi, prestasi tinggi, tanpa pelayan dan kebolehskalaan.

EFS boleh mengakses dan berkongsi fail dalam masa nyata daripada berbilang kejadian EC2 dan berskala secara automatik untuk memenuhi keperluan kapasiti dan prestasi. Dalam artikel ini, kami akan mendalami cara menggunakan Sistem Fail Elastik AWS (EFS) dalam Go.

Tetapan persekitaran

Sebelum menggunakan EFS, anda perlu menyediakan persekitaran yang betul terlebih dahulu. Kami memerlukan akaun AWS, AWS SDK for Go dan Go locale.

Pasang AWS SDK for Go

Anda boleh memasang AWS SDK for Go melalui arahan berikut:

$ go get github.com/aws/aws-sdk-go/aws
$ go get github.com/aws/aws-sdk-go/aws/session

Untuk mengesahkan sama ada AWS SDK dipasang dengan betul, anda boleh menulis program ujian berikut:

package main

import (
    "fmt"

    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
)

func main() {
    // Specify the AWS Region to use.
    sess, err := session.NewSessionWithOptions(session.Options{
        Config: aws.Config{
            Region: aws.String("us-west-2"),
        },
    })

    if err != nil {
        fmt.Println(err)
        return
    }

    // Create an S3 service client.
    s3 := NewS3(sess)

    // Verify the client by listing all buckets
    buckets, err := s3.ListBuckets(nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println("Buckets:")
    for _, b := range buckets.Buckets {
        fmt.Printf("* %s created on %s
",
            aws.StringValue(b.Name), aws.TimeValue(b.CreationDate))
    }
}

Jika semuanya berjalan lancar, output akan mengandungi senarai baldi AWS S3.

Buat sistem fail EFS

Sebelum menggunakan EFS, anda perlu mencipta sistem fail. Cipta sistem fail EFS dengan mengikut langkah berikut:

1. Log masuk ke konsol AWS.
2. Pilih EFS (Sistem Fail Elastik) dalam senarai perkhidmatan.
3. Klik butang Buat Sistem Fail.
4. Dalam halaman Cipta Sistem Fail, pilih VPC dan subnet (anda perlu memilih salah satu subnet awam untuk EFS disambungkan kepada semua kejadian EC2).
5. Dalam bahagian Kumpulan Keselamatan, pilih kumpulan keselamatan yang sepatutnya membenarkan semua trafik masuk dan keluar daripada tika EC2.
6. Dalam bahagian Sistem Fail dan Mod Prestasi, pilih pilihan Lalai.
7. Klik Buat Sistem Fail.

Apabila membuat sistem fail, sistem akan membuat kumpulan keselamatan khusus EFS secara automatik untuk anda membenarkan semua trafik data daripada VPC. Anda boleh mengatasi pilihan ini dengan peraturan kumpulan keselamatan anda sendiri.

Pasang pemacu EFS

Untuk menyepadukan aplikasi Go anda dengan EFS, anda perlu memasang pemacu AWS EFS. Pada Amazon Linux atau RHEL, pemacu EFS boleh dipasang dengan mengikuti langkah berikut:

1. Laksanakan arahan berikut untuk memasang kebergantungan pemacu EFS:

$ sudo yum install gcc libstdc++-devel gcc-c++ fuse fuse-devel automake openssl-devel git

2. Muat turun dan Bina pemacu EFS:

$ git clone https://github.com/aws-efs-utils/efs-utils
$ cd efs-utils
$ ./build-deb.sh

3. Pasang pemacu EFS:

$ sudo yum install ./build/amazon-efs-utils*rpm

4. Sahkan bahawa pemacu EFS dipasang dengan betul. Ini boleh disahkan dengan arahan berikut:

$ sudo mount -t efs fs-XXXXX:/ /mnt/efs

dengan fs-XXXX ialah ID sistem fail EFS anda. Jika tiada mesej ralat dalam output, pemasangan berjaya.

Menggunakan EFS

Selepas memasang pemacu EFS dan mencipta sistem fail EFS, anda boleh menyambungkan aplikasi Go anda kepada sistem fail EFS. Berikut ialah beberapa amalan terbaik untuk menggunakan EFS:

Dalam program, gunakan sistem fail EFS melalui perpustakaan standard sistem pengendalian. Dalam persekitaran bahasa Go, anda boleh menggunakan pakej syscall atau pakej os untuk menyambung ke sistem fail EFS.

Berikut ialah contoh coretan program untuk disambungkan ke EFS:

package main

import (
    "fmt"
    "os"
    "syscall"
)

func main() {
    // Mount EFS.
    if err := syscall.Mount("fs-XXXXX.efs.us-west-2.amazonaws.com:/", "/mnt/efs", "nfs4", 0, "rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2"); err != nil {
        fmt.Println("Unable to mount EFS file system:", err)
        os.Exit(1)
    }

    // List the files in the EFS file system.
    if files, err := os.ReadDir("/mnt/efs"); err != nil {
        fmt.Println("Unable to read files in EFS:", err)
    } else {
        fmt.Println("Files in EFS:")
        for _, file := range files {
            fmt.Println(file.Name())
        }
    }

    // Unmount EFS when done.
    if err := syscall.Unmount("/mnt/efs", 0); err != nil {
        fmt.Println("Unable to unmount EFS file system:", err)
        os.Exit(1)
    }
}

Dalam coretan kod di atas, kami telah menggunakan panggilan sistem untuk melekapkan sistem fail EFS dan menyenaraikan fail di dalamnya. Pada akhir program, kami menggunakan panggilan sistem untuk menyahlekap sistem fail.

Memandangkan EFS ialah API RESTful, ia menyokong semua operasi sistem fail standard seperti mencipta, membaca, menulis dan memadam fail. Dalam persekitaran bahasa Go, anda boleh menggunakan fungsi pakej os untuk melaksanakan operasi ini.

Berikut ialah contoh program untuk mencipta fail pada EFS:

package main

import (
    "fmt"
    "os"
)

func main() {
    // Create a new file in EFS.
    if file, err := os.Create("/mnt/efs/myfile.txt"); err != nil {
        fmt.Println("Unable to create file:", err)
        os.Exit(1)
    } else {
        defer file.Close()
        fmt.Println("File created successfully.")
    }
}

Dalam contoh di atas, kami menggunakan fungsi Cipta dalam pakej os untuk mencipta fail baharu pada sistem fail EFS. Fail ini mesti ditutup sebelum program tamat.

Kesimpulan

AWS Elastic File System (EFS) ialah sistem fail teragih yang berkuasa yang menyediakan ketersediaan tinggi, prestasi, tanpa pelayan dan kebolehskalaan. Dalam persekitaran bahasa Go, anda boleh menggunakan pakej syscall atau pakej os dalam pustaka standard untuk menyambung ke sistem fail EFS dan menggunakan semua fungsinya. Melalui panduan artikel ini, anda sepatutnya sudah mempunyai beberapa amalan terbaik untuk menggunakan EFS, supaya anda boleh menggunakan sepenuhnya fungsi EFS dalam persekitaran bahasa Go.

Atas ialah kandungan terperinci Menggunakan Sistem Fail Elastik AWS (EFS) dalam Go: Panduan Lengkap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!