Parlons des téléchargements de fichiers. Que vous construisiez le prochain Instagram, un CMS ou toute autre application impliquant du contenu généré par l'utilisateur, vous devrez gérer des fichiers. Aujourd'hui, nous plongeons dans le monde des téléchargements de fichiers avec Go. Nous allons mettre en place un simple service de téléchargement de fichiers capable de stocker des fichiers localement et, pour un peu plus de saveur, nous le connecterons même à Amazon S3 afin que vous puissiez passer en mode cloud complet. ?️

Voici le plan de match :

1. Configuration d'un point de terminaison de téléchargement de fichiers simple.
2. Gérer les fichiers, les stocker localement et s'assurer que tout fonctionne.
3. Ajout d'une validation de base pour assurer la sécurité des choses.
4. Et puis, nous passons à la vitesse supérieure avec le stockage S3.

Prenez votre café et c'est parti ! ☕

Étape 1 : Création du point de terminaison de téléchargement de fichiers

Tout d'abord : configurons un serveur HTTP de base avec un point de terminaison /upload. Pour cela, nous nous en tenons au package net/http intégré de Go car il est simple et simple à utiliser.

Configuration du serveur

Ouvrez votre éditeur préféré, créez un fichier main.go et configurez un serveur de base :

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/upload", fileUploadHandler)

    fmt.Println("Server running on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Création du gestionnaire de téléchargement

Passons maintenant à la partie amusante : gérer les téléchargements de fichiers ! Nous allons créer une fonction fileUploadHandler qui va gérer les fichiers entrants et les stocker dans un répertoire local.

func fileUploadHandler(w http.ResponseWriter, r *http.Request) {
    // Limit file size to 10MB. This line saves you from those accidental 100MB uploads!
    r.ParseMultipartForm(10 



Voici la vérité :

• Nous récupérons le fichier du formulaire avec r.FormFile("myFile").
• Après avoir obtenu le fichier, nous ouvrons (ou créons) un fichier local et copions le contenu.
• Cette configuration est idéale pour le stockage local, les prototypes rapides ou les projets qui ne sont pas encore prêts pour le stockage dans le cloud.

Enregistrer le fichier localement

Créons la fonction d'assistance createFile qui gère l'emplacement de nos fichiers :

import (
    "os"
    "path/filepath"
)

func createFile(filename string) (*os.File, error) {
    // Create an uploads directory if it doesn’t exist
    if _, err := os.Stat("uploads"); os.IsNotExist(err) {
        os.Mkdir("uploads", 0755)
    }

    // Build the file path and create it
    dst, err := os.Create(filepath.Join("uploads", filename))
    if err != nil {
        return nil, err
    }

    return dst, nil
}

Étape 2 : Valider et sécuriser vos fichiers ?️

La sécurité est la clé ! Ajoutons un peu de validation pour que seuls les types de fichiers approuvés soient acceptés.

Validation du type MIME

Vous voulez le garder en sécurité ? Limitons les téléchargements aux images. Voici comment :

import (
    "io/ioutil"
    "strings"
)

func isValidFileType(file []byte) bool {
    fileType := http.DetectContentType(file)
    return strings.HasPrefix(fileType, "image/") // Only allow images
}

func fileUploadHandler(w http.ResponseWriter, r *http.Request) {
    // [Existing code here]

    // Read the file into a byte slice to validate its type
    fileBytes, err := ioutil.ReadAll(file)
    if err != nil {
        http.Error(w, "Invalid file", http.StatusBadRequest)
        return
    }

    if !isValidFileType(fileBytes) {
        http.Error(w, "Invalid file type", http.StatusUnsupportedMediaType)
        return
    }

    // Proceed with saving the file
    if _, err := dst.Write(fileBytes); err != nil {
        http.Error(w, "Error saving the file", http.StatusInternalServerError)
    }
}

Étape 3 : Transférer vers le cloud avec S3 ☁️

Le stockage local, c'est bien, mais si vous souhaitez évoluer, S3 est l'endroit idéal ! Connectons votre service de téléchargement de fichiers à Amazon S3 afin que vous puissiez stocker des fichiers dans le cloud.

Installez le kit SDK AWS

Pour travailler avec S3, vous aurez besoin du SDK AWS :

go get -u github.com/aws/aws-sdk-go/aws
go get -u github.com/aws/aws-sdk-go/service/s3

Configurer le client S3

Configurons une fonction pour vous connecter à votre compartiment S3 :

import (
    "bytes"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/s3"
)

func uploadToS3(file []byte, filename string) error {
    sess, err := session.NewSession(&aws.Config{
        Region: aws.String("us-west-1"), // Your AWS region
    })
    if err != nil {
        return err
    }

    s3Client := s3.New(sess)
    _, err = s3Client.PutObject(&s3.PutObjectInput{
        Bucket: aws.String("your-bucket-name"),
        Key:    aws.String(filename),
        Body:   bytes.NewReader(file),
        ACL:    aws.String("public-read"),
    })
    return err
}

Remplacez « votre nom de compartiment » par le nom réel de votre compartiment S3. Maintenant, modifions notre gestionnaire de téléchargement pour utiliser cette fonction.

Modifier le gestionnaire de téléchargement

Mettez à jour fileUploadHandler afin que nous stockions le fichier dans S3 plutôt que localement :

func fileUploadHandler(w http.ResponseWriter, r *http.Request) {
    // [Existing code here]

    if err := uploadToS3(fileBytes, handler.Filename); err != nil {
        http.Error(w, "Error uploading to S3", http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "File successfully uploaded to S3!")
}

Et c'est tout ! Vous disposez désormais d'un service de téléchargement de fichiers qui prend en charge à la fois le stockage local et le stockage cloud via Amazon S3. ?

Le tester ?

Pour tester le service de téléchargement, vous pouvez utiliser curl :

curl -X POST http://localhost:8080/upload -F "myFile=@path/to/your/file.jpg"

Ou, si vous préférez une interface graphique, créez un formulaire HTML rapide :

Téléchargez un fichier et vous devriez le voir enregistré localement ou dans votre compartiment S3.

Conclusion

Créer un service de téléchargement de fichiers est un excellent moyen d'ajouter des fonctionnalités et d'en apprendre davantage sur la gestion, la validation et même le stockage dans le cloud des fichiers. Maintenant que vous maîtrisez les bases, réfléchissez à la suite : qu'il s'agisse du redimensionnement d'images, du traitement vidéo ou de la gestion de types de fichiers plus volumineux, il n'y a aucune limite !

Avez-vous déjà créé un service de téléchargement de fichiers ? Déposez un commentaire ci-dessous avec vos conseils ou dites-moi ce que vous aimeriez voir ensuite. Bon codage !