Introduction

Dans ce didacticiel, nous allons créer un puissant téléchargeur qui permet de télécharger des fichiers depuis Google Drive et d'autres fournisseurs de cloud. Grâce aux modèles de concurrence efficaces de Golang, vous pourrez gérer plusieurs téléchargements simultanément, diffuser des fichiers volumineux et suivre les progrès en temps réel. Que vous téléchargiez quelques petits fichiers ou que vous traitiez de grands ensembles de données, ce projet montrera comment créer un téléchargeur évolutif et robuste qui peut facilement être étendu pour prendre en charge plusieurs plates-formes cloud.

Si vous cherchez un moyen de simplifier et d'automatiser le téléchargement de fichiers volumineux, ce didacticiel est parfait pour vous. À la fin, vous disposerez d'un téléchargeur basé sur Go flexible et personnalisable pour répondre à vos besoins.

Pressé ?

Si vous souhaitez simplement utiliser ce téléchargeur avec une interface utilisateur, visitez moveasdev.com pour lire l'article complet et le Github de Go Downloader. Vous trouverez la documentation pour le faire fonctionner rapidement.

Ce que vous apprendrez

• Go Modèles de concurrence :
  Apprenez à utiliser les Goroutines, les canaux et les mutex pour gérer efficacement plusieurs téléchargements de fichiers simultanés.

• Diffusion de téléchargements volumineux :
  Découvrez comment diffuser des fichiers volumineux tout en gérant efficacement la mémoire et les ressources système.

• Téléchargements de fichiers simultanés :
  Découvrez comment télécharger des fichiers simultanément, accélérant le processus et améliorant les performances.

• Mises à jour des progrès en temps réel :
  Mettez en œuvre un suivi des progrès pour fournir des commentaires en temps réel sur l'état du téléchargement.

• Gestion des interruptions et des annulations :
  Découvrez comment annuler gracieusement un ou tous les téléchargements en cours.

Remarque : Ce didacticiel se concentrera uniquement sur la logique de téléchargement de base.

Configuration de l'environnement

Avant de faire quoi que ce soit, assurez-vous de configurer correctement votre environnement pour éviter des bugs potentiels à l'avenir.

Conditions préalables

• Installer Go
• AIR pour le rechargement automatique
• Makefile pour exécuter des commandes complexes
• Goose pour les migrations PostgreSQL

Configuration du Makefile

Créez un makefile à la racine du projet avec ce qui suit.

# 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

Présentation de la structure des dossiers de haut niveau

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

Définition des variables d'environnement

Créez un fichier .env à la racine ou gérez les variables d'environnement comme vous le souhaitez, nous utiliserons le package joho/godotenv.

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

Création d'un serveur Web

Nous allons maintenant commencer à créer le serveur Web qui gérera toutes les requêtes entrantes.

Attention ! La partie principale de ce guide commence ici. Préparez-vous à plonger !

Couche API

Pour commencer, créez les fichiers suivants dans le dossier API api.go et route.go

configuration du fichier route.go

Toutes les routes API seront définies ici. Nous créons une structure NewRouter qui prend la configuration env, permettant à toutes les routes et gestionnaires d'accéder aux variables d'environnement.

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

configuration du fichier api.go

Ici, nous ajouterons tous les middlewares nécessaires, tels que CORS et la journalisation, avant de démarrer le serveur.

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

Point d'entrée principal

Il s'agit du package principal du fichier main.go qui servira de point d'entrée à l'ensemble.

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

    log.Fatal(s.Start())
}

Cela suffit pour démarrer le serveur et le tester.

Démarrer le serveur

air

c'est ça.?

Essai

curl http://localhost:3000/healthcheck

La réponse doit être OK avec le statut 200

Création d'un magasin de fournisseurs

Nous devons mettre en œuvre une solution évolutive pour ajouter la prise en charge de plusieurs fournisseurs de cloud si nécessaire.

Travailler sur le registre des fournisseurs

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

Le ProviderRegistry sert de carte centrale pour contenir tous nos fournisseurs OAuth. Lorsque nous initialiserons nos fournisseurs, nous les enregistrerons dans cette carte. Cela nous permet d'accéder facilement aux fonctionnalités de tout fournisseur enregistré tout au long de notre service.

Vous verrez cette action plus tard.

Initialisation du magasin de fournisseurs

Nous enregistrerons nos fournisseurs en fonction des variables d'environnement fournies.

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
}

Lisez l'article complet ici.

Conclusion

Nous avons jeté les bases du Google Drive Downloader dans Go, en couvrant des éléments clés tels que la configuration de la structure du projet, la gestion de Google OAuth et la pose des bases d'une expansion future. En cours de route, nous avons abordé quelques sujets importants :

• Migrations de bases de données avec Goose pour garantir une gestion des données fluide et évolutive.
• Création d'un registre de fournisseurs pour étendre facilement la prise en charge de fournisseurs de stockage cloud supplémentaires à l'avenir.
• Concevoir une architecture flexible qui facilite la gestion ultérieure d'une logique plus complexe.

C'est largement suffisant pour un seul article, car les choses devenaient assez longues ! Nous reviendrons dans la Partie 2 pour terminer notre travail, où nous travaillerons sur la principale fonctionnalité de téléchargement.

D'ici là, n'hésitez pas à explorer l'implémentation actuelle dans mon GitHub et restez à l'écoute pour les prochaines étapes. Bon téléchargement !