Verwenden von AWS Elastic File System (EFS) in Go: Eine vollständige Anleitung

Mit der weit verbreiteten Anwendung von Cloud-Computing-Technologie und Containeranwendungen beginnen immer mehr Unternehmen, Anwendungen von herkömmlichen physischen Servern zur Bereitstellung und zum Betrieb in Cloud-Umgebungen zu migrieren. Der Einsatz leistungsstarker Speichersysteme in Cloud-Umgebungen ist ein sehr wichtiges Thema, und AWS Elastic File System (EFS) ist ein leistungsstarkes verteiltes Dateisystem, das hohe Verfügbarkeit, hohe Leistung, Serverlosigkeit und Skalierbarkeit bieten kann.

EFS kann in Echtzeit von mehreren EC2-Instanzen auf Dateien zugreifen und diese teilen und skaliert automatisch, um den Kapazitäts- und Leistungsanforderungen gerecht zu werden. In diesem Artikel werden wir uns eingehend mit der Verwendung des AWS Elastic File System (EFS) in Go befassen.

Umgebungseinstellungen

Bevor Sie EFS verwenden, müssen Sie zunächst die richtige Umgebung einrichten. Wir benötigen ein AWS-Konto, ein AWS SDK für Go und ein Go-Gebietsschema.

AWS SDK für Go installieren

Sie können AWS SDK für Go mit dem folgenden Befehl installieren:

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

Um zu überprüfen, ob das AWS SDK korrekt installiert ist, können Sie das folgende Testprogramm schreiben:

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

Wenn alles gut geht, Die Ausgabe enthält eine AWS-Liste der S3-Buckets.

Erstellen Sie ein EFS-Dateisystem

Bevor Sie EFS verwenden, müssen Sie ein Dateisystem erstellen. Erstellen Sie ein EFS-Dateisystem, indem Sie die folgenden Schritte ausführen:

1. Melden Sie sich bei der AWS-Konsole an.
2. Wählen Sie EFS (Elastic File System) in der Dienstliste.
3. Klicken Sie auf die Schaltfläche Dateisystem erstellen.
4. Wählen Sie auf der Seite „Dateisystem erstellen“ Ihre VPC und Ihr Subnetz aus (Sie müssen eines der öffentlichen Subnetze auswählen, damit EFS alle EC2-Instanzen verbinden kann).
5. Wählen Sie im Abschnitt „Sicherheitsgruppe“ eine Sicherheitsgruppe aus, die den gesamten ein- und ausgehenden Datenverkehr von der EC2-Instanz zulassen soll.
6. Wählen Sie im Abschnitt Dateisystem und Leistungsmodus die Option Standard aus.
7. Klicken Sie auf Dateisystem erstellen.

Beim Erstellen eines Dateisystems erstellt das System automatisch eine EFS-dedizierte Sicherheitsgruppe für Sie, um den gesamten Datenverkehr von der VPC zuzulassen. Sie können diese Option mit Ihren eigenen Sicherheitsgruppenregeln überschreiben.

Installieren Sie den EFS-Treiber

Um Ihre Go-Anwendung mit EFS zu integrieren, müssen Sie den AWS EFS-Treiber installieren. Unter Amazon Linux oder RHEL können Sie den EFS-Treiber installieren, indem Sie die folgenden Schritte ausführen:

1. Führen Sie den folgenden Befehl aus, um die EFS-Treiberabhängigkeiten zu installieren:

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

2. Laden Sie den EFS-Treiber herunter und erstellen Sie ihn:

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

3. Installieren Sie den EFS-Treiber Vorgehensweise:

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

4. Bestätigen Sie, dass der EFS-Treiber korrekt installiert ist. Dies kann mit dem folgenden Befehl überprüft werden:

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

wobei fs-XXXXX die ID Ihres EFS-Dateisystems ist. Wenn in der Ausgabe keine Fehlermeldungen angezeigt werden, ist die Installation erfolgreich.

Verwenden von EFS

Nach der Installation des EFS-Treibers und der Erstellung des EFS-Dateisystems können Sie Ihre Go-Anwendung mit dem EFS-Dateisystem verbinden. Im Folgenden finden Sie einige Best Practices für die Verwendung von EFS:

Verwenden Sie in Programmen das EFS-Dateisystem über die Standardbibliothek des Betriebssystems. In der Go-Sprachumgebung können Sie das Syscall-Paket oder das OS-Paket verwenden, um eine Verbindung zum EFS-Dateisystem herzustellen.

Hier ist ein Beispielprogrammausschnitt zum Herstellen einer Verbindung mit 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)
    }
}

Im obigen Codeausschnitt haben wir einen Systemaufruf verwendet, um das EFS-Dateisystem zu mounten und die darin enthaltenen Dateien aufzulisten. Am Ende des Programms haben wir einen Systemaufruf verwendet, um das Dateisystem auszuhängen.

Da EFS eine RESTful-API ist, unterstützt es alle Standard-Dateisystemvorgänge wie das Erstellen, Lesen, Schreiben und Löschen von Dateien. In der Go-Sprachumgebung können Sie die Funktionen des Betriebssystempakets verwenden, um diese Vorgänge auszuführen.

Hier ist ein Beispielprogramm zum Erstellen einer Datei auf 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.")
    }
}

Im obigen Beispiel verwenden wir die Create-Funktion im Betriebssystempaket, um eine neue Datei im EFS-Dateisystem zu erstellen. Diese Datei muss geschlossen werden, bevor das Programm beendet wird.

Fazit

AWS Elastic File System (EFS) ist ein leistungsstarkes verteiltes Dateisystem, das hohe Verfügbarkeit, Leistung, Serverlosigkeit und Skalierbarkeit bietet. In der Go-Sprachumgebung können Sie das Syscall-Paket oder das OS-Paket in der Standardbibliothek verwenden, um eine Verbindung zum EFS-Dateisystem herzustellen und alle seine Funktionen zu nutzen. Mithilfe der Anleitung in diesem Artikel sollten Sie bereits über einige Best Practices für die Verwendung von EFS verfügen, sodass Sie die Funktionen von EFS in der Go-Sprachumgebung vollständig nutzen können.

Das obige ist der detaillierte Inhalt vonVerwenden von AWS Elastic File System (EFS) in Go: Eine vollständige Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!