Erstellen eines Google Drive Downloaders in Golang (Teil 1)

Einführung

In diesem Tutorial erstellen wir einen leistungsstarken Downloader, der das Herunterladen von Dateien von Google Drive und anderen Cloud-Anbietern ermöglicht. Mit den effizienten Parallelitätsmustern von Golang können Sie mehrere Downloads gleichzeitig verwalten, große Dateien streamen und den Fortschritt in Echtzeit verfolgen. Unabhängig davon, ob Sie ein paar kleine Dateien herunterladen oder große Datenmengen verarbeiten, zeigt dieses Projekt, wie Sie einen skalierbaren und robusten Downloader erstellen, der problemlos erweitert werden kann, um mehrere Cloud-Plattformen zu unterstützen.

Wenn Sie nach einer Möglichkeit suchen, das Herunterladen großer Dateien zu vereinfachen und zu automatisieren, ist dieses Tutorial genau das Richtige für Sie. Am Ende verfügen Sie über einen flexiblen und anpassbaren Go-basierten Downloader, der Ihren Anforderungen entspricht.

In Eile?

Wenn Sie diesen Downloader nur mit einer Benutzeroberfläche verwenden möchten, besuchen Sie evolutionasdev.com, um den vollständigen Artikel zu lesen und Go Downloader's Github zu besuchen. Sie finden die Dokumente, um es schnell zum Laufen zu bringen.

Was Sie lernen werden

• Go-Parallelitätsmuster:
  Erfahren Sie, wie Sie Goroutinen, Kanäle und Mutexe verwenden, um mehrere gleichzeitige Dateidownloads effizient abzuwickeln.

• Große Downloads streamen:
  Erfahren Sie, wie Sie große Dateien streamen und gleichzeitig Speicher und Systemressourcen effektiv verwalten.

• Gleichzeitige Dateidownloads:
  Erfahren Sie, wie Sie Dateien gleichzeitig herunterladen, den Prozess beschleunigen und die Leistung verbessern.

• Fortschrittsaktualisierungen in Echtzeit:
  Implementieren Sie eine Fortschrittsverfolgung, um Echtzeit-Feedback zum Download-Status zu geben.

• Umgang mit Unterbrechungen und Stornierungen:
  Erfahren Sie, wie Sie einen oder alle laufenden Downloads ordnungsgemäß abbrechen können.

Hinweis: Dieses Tutorial konzentriert sich nur auf die Kern-Download-Logik.

Umgebungseinrichtung

Bevor Sie etwas unternehmen, stellen Sie zunächst sicher, dass Sie Ihre Umgebung richtig einrichten, um potenzielle Fehler in Zukunft zu vermeiden.

Voraussetzungen

• Go installieren
• AIR für automatisches Nachladen
• Makefile zum Ausführen komplexer Befehle
• Goose für PostgreSQL-Migrationen

Makefile konfigurieren

Erstellen Sie mit Folgendem ein Makefile im Stammverzeichnis des Projekts.

# 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

Übersicht über die Ordnerstruktur auf hoher Ebene

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

Umgebungsvariablen festlegen

Erstellen Sie eine .env-Datei im Stammverzeichnis oder behandeln Sie Umgebungsvariablen nach Ihren Wünschen. Wir verwenden das Paket joho/godotenv.

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

Erstellen eines Webservers

Wir beginnen nun mit der Erstellung des Webservers, der alle eingehenden Anfragen verarbeitet.

Achtung! Der Hauptteil dieses Leitfadens beginnt hier. Machen Sie sich bereit zum Eintauchen!

API-Schicht

Erstellen Sie zunächst die folgenden Dateien im API-Ordner api.go und route.go

Einrichtung der Route.go-Datei

Alle API-Routen werden hierin definiert. Wir erstellen eine NewRouter-Struktur, die die Umgebungskonfiguration übernimmt und allen Routen und Handlern den Zugriff auf Umgebungsvariablen ermöglicht.

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

Einrichtung der api.go-Datei

Hier fügen wir alle notwendigen Middlewares wie CORS und Protokollierung hinzu, bevor wir den Server starten.

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

Haupteinstiegspunkt

Dies ist das Hauptpaket in der Datei main.go, das als Einstiegspunkt für das Ganze fungiert.

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

    log.Fatal(s.Start())
}

Dies reicht aus, um den Server zu starten und zu testen.

Starten Sie den Server

air

das ist es.?

Testen

curl http://localhost:3000/healthcheck

Die Antwort sollte OK sein und den Status 200 haben

Erstellen eines Provider Stores

Wir müssen eine skalierbare Lösung implementieren, um bei Bedarf Unterstützung für mehrere Cloud-Anbieter hinzuzufügen.

Arbeiten an der Anbieterregistrierung

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

Die ProviderRegistry dient als zentrale Karte für alle unsere OAuth-Anbieter. Wenn wir unsere Anbieter initialisieren, registrieren wir sie in dieser Karte. Dies ermöglicht uns den einfachen Zugriff auf die Funktionalitäten aller registrierten Anbieter während unseres gesamten Dienstes.

Sie werden diese Aktion später sehen.

Initialisieren des Provider Stores

Wir registrieren unsere Anbieter basierend auf den bereitgestellten Umgebungsvariablen.

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
}

Lesen Sie den vollständigen Artikel hier.

Zusammenfassung

Wir haben den Grundstein für den Google Drive Downloader in Go gelegt und dabei wichtige Komponenten wie die Einrichtung der Projektstruktur, die Handhabung von Google OAuth und die Grundsteinlegung für zukünftige Erweiterungen abgedeckt. Unterwegs haben wir einige wichtige Themen angesprochen:

• Datenbankmigrationen mit Goose, um eine reibungslose und skalierbare Datenverwaltung zu gewährleisten.
• Aufbau eines Anbieterregisters, um die Unterstützung für weitere Cloud-Speicheranbieter in Zukunft einfach zu erweitern.
• Entwerfen einer flexiblen Architektur, die es einfacher macht, später komplexere Logik zu handhaben.

Das ist mehr als genug für einen Beitrag, da die Dinge ziemlich lang wurden! Wir werden in Teil 2 zurückkommen, um unsere Arbeit abzuschließen, wo wir die Haupt-Download-Funktionalität bearbeiten werden.

Bis dahin können Sie die aktuelle Implementierung gerne auf meinem GitHub erkunden und für die nächsten Schritte gespannt sein. Viel Spaß beim Herunterladen!

Das obige ist der detaillierte Inhalt vonErstellen eines Google Drive Downloaders in Golang (Teil 1). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!