Introducción

En este tutorial, crearemos un potente descargador que permita descargar archivos de Google Drive y otros proveedores de nube. Con los eficientes patrones de concurrencia de Golang, podrá administrar múltiples descargas simultáneamente, transmitir archivos grandes y realizar un seguimiento del progreso en tiempo real. Ya sea que esté descargando algunos archivos pequeños o manejando grandes conjuntos de datos, este proyecto le mostrará cómo crear un descargador escalable y robusto que pueda ampliarse fácilmente para admitir múltiples plataformas en la nube.

Si estás buscando una manera de simplificar y automatizar la descarga de archivos grandes, este tutorial es perfecto para ti. Al final, tendrás un descargador basado en Go flexible y personalizable que se adaptará a tus necesidades.

¿Apurado?

Si solo desea utilizar este descargador con una interfaz de usuario, visite evolucionaasdev.com para leer el artículo completo y el Github de Go Downloader. Encontrarás los documentos para que funcione rápidamente.

Lo que aprenderás

• Ir a patrones de concurrencia:
  Aprenda a utilizar Goroutines, canales y mutex para manejar múltiples descargas simultáneas de archivos de manera eficiente.

• Transmisión de descargas grandes:
  Explore cómo transmitir archivos grandes mientras administra la memoria y los recursos del sistema de manera efectiva.

• Descargas de archivos simultáneas:
  Comprenda cómo descargar archivos simultáneamente, acelerando el proceso y mejorando el rendimiento.

• Actualizaciones de progreso en tiempo real:
  Implemente el seguimiento del progreso para proporcionar comentarios en tiempo real sobre el estado de la descarga.

• Manejo de interrupciones y cancelaciones:
  Aprenda cómo cancelar correctamente una o todas las descargas en curso.

Nota: Este tutorial solo se centrará en la lógica de descarga principal.

Configuración del entorno

Primero, antes de hacer cualquier cosa, asegúrese de configurar correctamente su entorno para evitar posibles errores en el futuro.

Requisitos previos

• Instalar Go
• AIR para recarga automática
• Makefile para ejecutar comandos complejos
• Goose para migraciones PostgreSQL

Configurando el archivo Make

Cree un archivo MAKE en la raíz del proyecto con lo siguiente.

# Load environment variables from .env file
include ./.env

# To run the application
run: build
    @./bin/go-downloader

# Build the application
build:
    @go build -tags '!dev' -o bin/go-downloader

# Database migration status
db-status:
    @GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) status

# Run database migrations
up:
    @GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) up

# Roll back the last database migration
down:
    @GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) down

# Reset database migrations
reset:
    @GOOSE_DRIVER=postgres GOOSE_DBSTRING=$(DB_URL) goose -dir=$(migrationPath) reset

Descripción general de la estructura de carpetas de alto nivel

go-downloader/
├── api
├── config
├── migrations
├── service
├── setting
├── store
├── types
├── util
├── .env
├── .air.toml
├── Makefile
├── go.mod
├── go.sum
└── main.go

Configuración de variables de entorno

Cree un archivo .env en la raíz o maneje las variables de entorno como desee, usaremos el paquete joho/godotenv.

GOOGLE_CLIENT_ID
GOOGLE_CLIENT_SECRET
SESSION_SECRET=something-super-secret
APP_URL=http://localhost:3000
POSTGRES_USER
POSTGRES_PASSWORD
POSTGRES_DB

Creando un servidor web

Ahora comenzaremos a crear el servidor web que manejará todas las solicitudes entrantes.

¡Atención! La parte principal de esta guía comienza aquí. ¡Prepárate para sumergirte!

Capa API

Para comenzar, cree los siguientes archivos dentro de la carpeta api api.go y route.go

configuración del archivo route.go

Todas las rutas API se definirán aquí. Creamos una estructura NewRouter que toma la configuración env, permitiendo que todas las rutas y controladores accedan a las variables de entorno.

package api

import (
    "github.com/gofiber/fiber/v2"
    "github.com/nilotpaul/go-downloader/config"
)

type Router struct {
    env       config.EnvConfig
}

func NewRouter(env config.EnvConfig) *Router {
    return &Router{
        env:      env,
    }
}

func (h *Router) RegisterRoutes(r fiber.Router) {
    r.Get("/healthcheck", func(c *fiber.Ctx) error {
        return c.JSON("OK")
    })
}

configuración del archivo api.go

Aquí, agregaremos todos los middlewares necesarios, como CORS y registro, antes de iniciar el servidor.

type APIServer struct {
    listenAddr string
    env        config.EnvConfig
}

func NewAPIServer(listenAddr string, env config.EnvConfig) *APIServer {
    return &APIServer{
        listenAddr: listenAddr,
        env:        env,
    }
}

func (s *APIServer) Start() error {
    app := fiber.New(fiber.Config{
        AppName:      "Go Downloader",
    })

    handler := NewRouter()
    handler.RegisterRoutes(app)

    log.Printf("Server started on http://localhost:%s", s.listenAddr)

    return app.Listen(":"   s.listenAddr)
}

Punto de entrada principal

Este es el paquete principal en el archivo main.go que actuará como punto de entrada al conjunto.

func main() {
    // Loads all Env vars from .env file.
    env := config.MustLoadEnv()

    log.Fatal(s.Start())
}

Esto es suficiente para iniciar el servidor y probarlo.

Iniciar el servidor

air

eso es todo.?

Pruebas

curl http://localhost:3000/healthcheck

La respuesta debería estar bien con el estado 200

Crear una tienda de proveedores

Necesitamos implementar una solución escalable para agregar soporte para múltiples proveedores de nube si es necesario.

Trabajando en el registro de proveedores

// Better to keep it in a seperate folder.
// Specific only to OAuth Providers.
type OAuthProvider interface {
    Authenticate(string) error
    GetAccessToken() string
    GetRefreshToken() string
    RefreshToken(*fiber.Ctx, string, bool) (*oauth2.Token, error)
    IsTokenValid() bool
    GetAuthURL(state string) string
    CreateOrUpdateAccount() (string, error)
    CreateSession(c *fiber.Ctx, userID string) error
    UpdateTokens(*GoogleAccount) error
}

type ProviderRegistry struct {
    Providers map[string]OAuthProvider
}

func NewProviderRegistry() *ProviderRegistry {
    return &ProviderRegistry{
        Providers: make(map[string]OAuthProvider),
    }
}

func (r *ProviderRegistry) Register(providerName string, p OAuthProvider) {
    r.Providers[providerName] = p
}

func (r *ProviderRegistry) GetProvider(providerName string) (OAuthProvider, error) {
    p, exists := r.Providers[providerName]
    if !exists {
        return nil, fmt.Errorf("Provider not found")
    }

    return p, nil
}

ProviderRegistry sirve como un mapa central para contener todos nuestros proveedores de OAuth. Cuando inicialicemos nuestros proveedores, los registraremos en este mapa. Esto nos permite acceder fácilmente a las funcionalidades de cualquier proveedor registrado a lo largo de nuestro servicio.

Verás esta acción más tarde.

Inicializando la tienda de proveedores

Registraremos a nuestros proveedores según las variables de entorno proporcionadas.

func InitStore(env config.EnvConfig) *ProviderRegistry {
    r := NewProviderRegistry()

    if len(env.GoogleClientSecret) != 0 || len(env.GoogleClientID) != 0 {
        googleProvider := NewGoogleProvider(googleProviderConfig{
            googleClientID:     env.GoogleClientID,
            googleClientSecret: env.GoogleClientSecret,
            googleRedirectURL:  env.AppURL   "/callback/google",
        }, env)

        r.Register("google", googleProvider)
    }

    return r
}

Lea el artículo completo aquí.

Concluyendo

Hemos sentado las bases para Google Drive Downloader en Go, cubriendo componentes clave como la configuración de la estructura del proyecto, el manejo de Google OAuth y sentando las bases para una futura expansión. En el camino, tocamos algunos temas importantes:

• Migraciones de bases de datos con Goose para garantizar una gestión de datos fluida y escalable.
• Creación de un registro de proveedores para ampliar fácilmente el soporte para proveedores adicionales de almacenamiento en la nube en el futuro.
• Diseñar una arquitectura flexible que facilite el manejo de lógicas más complejas en el futuro.

¡Eso es más que suficiente para una publicación, ya que las cosas se estaban volviendo bastante largas! Volveremos en la Parte 2 para terminar nuestro trabajo, donde trabajaremos en la funcionalidad de descarga principal.

Hasta entonces, siéntete libre de explorar la implementación actual en mi GitHub y mantente atento a los próximos pasos. ¡Feliz descarga!