在 Golang 中构建 Google Drive 下载器（第 1 部分）

Introduction

Dans ce didacticiel, nous allons créer un téléchargeur puissant 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 tutoriel 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 cherchez 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 simultanés de fichiers :
  Comprenez 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 tutoriel 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 devrait ê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.

总结

我们已经为 Go 中的 Google Drive Downloader 奠定了基础，涵盖了设置项目结构、处理 Google OAuth 等关键组件，并为未来的扩展奠定了基础。一路上，我们触及了一些重要的话题：

• 使用 Goose 进行数据库迁移，以确保平稳且可扩展的数据管理。
• 构建提供商注册表以便将来轻松扩展对其他云存储提供商的支持。
• 设计灵活的架构，以便轻松处理未来更复杂的逻辑。

这对于一篇文章来说已经足够了，因为事情变得相当长了！我们将在第 2 部分中回来完成我们的工作，我们将在其中处理主要的下载功能。

在那之前，请随意探索我的 GitHub 中的当前实现，并继续关注后续步骤。祝您下载愉快！

以上是在 Golang 中构建 Google Drive 下载器（第 1 部分）的详细内容。更多信息请关注PHP中文网其他相关文章！