Hablemos de carga de archivos. Ya sea que esté creando el próximo Instagram, un CMS o cualquier aplicación que involucre contenido generado por el usuario, necesitará manejar archivos. Hoy nos sumergimos en el mundo de la carga de archivos con Go. Configuraremos un servicio de carga de archivos simple que puede almacenar archivos localmente y, para darle un toque extra, incluso lo conectaremos a Amazon S3 para que pueda pasar al modo de nube completa. ?️

Aquí está el plan de juego:

1. Configuración de un punto final de carga de archivos simple.
2. Manejar archivos, almacenarlos localmente y asegurarse de que todo funcione.
3. Agregar validación básica para mantener las cosas seguras.
4. Y luego, vamos a ir un paso más allá con el almacenamiento S3.

¡Toma tu café y vámonos! ☕

Paso 1: crear el punto final de carga de archivos

Lo primero es lo primero: configuremos un servidor HTTP básico con un punto final /upload. Para esto, nos atenemos al paquete net/http integrado de Go porque es sencillo y fácil de usar.

Configuración del servidor

Abre tu editor favorito, crea un archivo main.go y configura un servidor básico:

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

Creando el controlador de carga

Ahora vayamos a la parte divertida: ¡manejar la carga de archivos! Crearemos una función fileUploadHandler que manejará los archivos entrantes y los almacenará en un directorio 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 



Aquí está la verdad:

• Estamos tomando el archivo del formulario con r.FormFile("myFile").
• Después de obtener el archivo, abrimos (o creamos) un archivo local y copiamos el contenido.
• Esta configuración es excelente para almacenamiento local, prototipos rápidos o proyectos que aún no están listos para el almacenamiento en la nube.

Guardar el archivo localmente

Creemos la función auxiliar createFile que maneja dónde van nuestros archivos:

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
}

Paso 2: ¿Validar y proteger sus archivos?️

¡La seguridad es clave! Agreguemos un poco de validación para que solo los tipos de archivos aprobados pasen.

Validando el tipo MIME

¿Quieres mantenerlo seguro? Restrinjamos las cargas a imágenes. Así es como:

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

Paso 3: llevarlo a la nube con S3 ☁️

El almacenamiento local está bien y todo, pero si quieres escalar, ¡S3 es donde está! Conectemos su servicio de carga de archivos a Amazon S3 para que pueda almacenar archivos en la nube.

Instale el SDK de AWS

Para trabajar con S3, necesitará el SDK de AWS:

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

Configurar el cliente S3

Configuremos una función para conectarnos a su depósito 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
}

Reemplace "su-nombre-de-depósito" con el nombre real de su depósito de S3. Ahora, modifiquemos nuestro controlador de carga para usar esta función.

Modificar el controlador de carga

Actualice fileUploadHandler para almacenar el archivo en S3 en lugar de localmente:

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

¡Y listo! Ahora tiene un servicio de carga de archivos que admite almacenamiento local y almacenamiento en la nube a través de Amazon S3. ?

¿Probarlo?

Para probar el servicio de carga, puedes usar curl:

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

O, si prefieres una interfaz gráfica, crea un formulario HTML rápido:

Sube un archivo y deberías verlo guardado localmente o en tu depósito de S3.

Concluyendo

Crear un servicio de carga de archivos es una excelente manera de agregar funcionalidad y aprender sobre el manejo, la validación e incluso el almacenamiento en la nube de archivos. Ahora que ya dominas los conceptos básicos, piensa en lo que sigue: ya sea cambiar el tamaño de la imagen, procesar videos o manejar tipos de archivos más grandes, ¡el cielo es el límite!

¿Has creado un servicio de carga de archivos antes? Deja un comentario a continuación con tus consejos o cuéntame qué te gustaría ver a continuación. ¡Feliz codificación!