Utilisation d'AWS Elastic File System (EFS) dans Go : un guide complet

Avec l'application généralisée de la technologie du cloud computing et des applications conteneurisées, de plus en plus d'entreprises commencent à migrer leurs applications des serveurs physiques traditionnels vers des environnements cloud pour le déploiement et l'exploitation. L'utilisation de systèmes de stockage hautes performances dans des environnements cloud est un problème très important, et AWS Elastic File System (EFS) est un puissant système de fichiers distribué qui peut offrir une haute disponibilité, des performances élevées, sans serveur et une évolutivité.

EFS peut accéder et partager des fichiers en temps réel à partir de plusieurs instances EC2 et évolue automatiquement pour répondre aux besoins de capacité et de performances. Dans cet article, nous examinerons en profondeur comment utiliser AWS Elastic File System (EFS) dans Go.

Paramètres d'environnement

Avant d'utiliser EFS, vous devez d'abord configurer le bon environnement. Nous avons besoin d'un compte AWS, d'AWS SDK for Go et de paramètres régionaux Go.

Installer AWS SDK for Go

Vous pouvez installer AWS SDK for Go avec la commande suivante :

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

Pour vérifier que le AWS SDK est correctement installé, vous pouvez écrire le programme de test suivant :

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

Si tout se passe bien, la sortie contiendra la liste AWS des compartiments S3.

Créer un système de fichiers EFS

Avant d'utiliser EFS, vous devez créer un système de fichiers. Créez un système de fichiers EFS en suivant ces étapes :

1. Connectez-vous à la console AWS.
2. Sélectionnez EFS (Elastic File System) dans la liste des services.
3. Cliquez sur le bouton Créer un système de fichiers.
4. Dans la page Créer un système de fichiers, sélectionnez votre VPC et votre sous-réseau (vous devez sélectionner l'un des sous-réseaux publics pour qu'EFS connecte toutes les instances EC2).
5. Dans la section Groupe de sécurité, sélectionnez un groupe de sécurité qui doit autoriser tout le trafic entrant et sortant de l'instance EC2.
6. Dans la section Système de fichiers et mode de performances, sélectionnez l'option Par défaut.
7. Cliquez sur Créer un système de fichiers.

Lors de la création d'un système de fichiers, le système créera automatiquement un groupe de sécurité dédié à EFS pour vous permettre d'autoriser tout le trafic de données depuis le VPC. Vous pouvez remplacer cette option par vos propres règles de groupe de sécurité.

Installer le pilote EFS

Afin d'intégrer votre application Go à EFS, vous devez installer le pilote AWS EFS. Sur Amazon Linux ou RHEL, vous pouvez installer le pilote EFS en suivant ces étapes :

1. Exécutez la commande suivante pour installer les dépendances du pilote EFS :

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

2. Téléchargez et créez le pilote EFS :

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

3. Installez le Pilote EFS Procédure :

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

4. Confirmez que le pilote EFS est correctement installé. Cela peut être vérifié avec la commande suivante :

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

où fs-XXXXX est l'ID de votre système de fichiers EFS. S'il n'y a aucun message d'erreur dans la sortie, l'installation a réussi.

Utilisation d'EFS

Après avoir installé le pilote EFS et créé le système de fichiers EFS, vous pouvez connecter votre application Go au système de fichiers EFS. Voici quelques bonnes pratiques pour utiliser EFS :

Dans les programmes, utilisez le système de fichiers EFS via la bibliothèque standard du système d'exploitation. Dans l'environnement du langage Go, vous pouvez utiliser le package syscall ou le package os pour vous connecter au système de fichiers EFS.

Voici un exemple d'extrait de programme pour se connecter à 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)
    }
}

Dans l'extrait de code ci-dessus, nous avons utilisé un appel système pour monter le système de fichiers EFS et répertorier les fichiers qu'il contient. À la fin du programme, nous avons utilisé un appel système pour démonter le système de fichiers.

Étant donné qu'EFS est une API RESTful, il prend en charge toutes les opérations standard du système de fichiers telles que la création, la lecture, l'écriture et la suppression de fichiers. Dans l'environnement du langage Go, vous pouvez utiliser les fonctions du package os pour effectuer ces opérations.

Voici un exemple de programme pour créer un fichier sur 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.")
    }
}

Dans l'exemple ci-dessus, nous utilisons la fonction Create du package os pour créer un nouveau fichier sur le système de fichiers EFS. Ce fichier doit être fermé avant la fin du programme.

Conclusion

AWS Elastic File System (EFS) est un puissant système de fichiers distribué qui offre haute disponibilité, performances, sans serveur et évolutivité. Dans l'environnement du langage Go, vous pouvez utiliser le package syscall ou le package os dans la bibliothèque standard pour vous connecter au système de fichiers EFS et utiliser toutes ses fonctions. Grâce aux conseils de cet article, vous devriez déjà connaître quelques bonnes pratiques pour utiliser EFS, afin de pouvoir utiliser pleinement les fonctions d'EFS dans l'environnement linguistique Go.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!