परिचय

इस ट्यूटोरियल में, हम एक शक्तिशाली डाउनलोडर बनाएंगे जो Google Drive और अन्य क्लाउड प्रदाताओं से फ़ाइलें डाउनलोड करने की अनुमति देता है। गोलांग के कुशल समवर्ती पैटर्न के साथ, आप एक साथ कई डाउनलोड प्रबंधित करने, बड़ी फ़ाइलों को स्ट्रीम करने और वास्तविक समय में प्रगति को ट्रैक करने में सक्षम होंगे। चाहे आप कुछ छोटी फ़ाइलें डाउनलोड कर रहे हों या बड़े डेटा सेट संभाल रहे हों, यह प्रोजेक्ट दिखाएगा कि एक स्केलेबल और मजबूत डाउनलोडर कैसे बनाया जाए जिसे आसानी से कई क्लाउड प्लेटफ़ॉर्म का समर्थन करने के लिए बढ़ाया जा सके।

यदि आप बड़ी फ़ाइलों को डाउनलोड करने को सरल और स्वचालित करने का कोई तरीका ढूंढ रहे हैं, तो यह ट्यूटोरियल आपके लिए बिल्कुल सही है। अंत तक, आपके पास आपकी आवश्यकताओं के अनुरूप एक लचीला और अनुकूलन योग्य गो-आधारित डाउनलोडर होगा।

जल्दी में?

यदि आप इस डाउनलोडर को यूआई के साथ उपयोग करना चाहते हैं, तो पूरा लेख पढ़ने के लिए evolveasdev.com पर जाएं और डाउनलोडर के जीथब पर जाएं। आपको इसे तेजी से चलाने के लिए दस्तावेज़ मिलेंगे।

आप क्या सीखेंगे

• गो समवर्ती पैटर्न:
  एकाधिक समवर्ती फ़ाइल डाउनलोड को कुशलतापूर्वक प्रबंधित करने के लिए गोरआउट्स, चैनल और म्यूटेक्स का उपयोग करना सीखें।

• बड़े डाउनलोड स्ट्रीमिंग:
  मेमोरी और सिस्टम संसाधनों को प्रभावी ढंग से प्रबंधित करते हुए बड़ी फ़ाइलों को स्ट्रीम करने का तरीका जानें।

• समवर्ती फ़ाइल डाउनलोड:
  समझें कि फ़ाइलों को एक साथ कैसे डाउनलोड करें, प्रक्रिया को तेज़ करें और प्रदर्शन में सुधार करें।

• वास्तविक समय प्रगति अपडेट:
  डाउनलोड स्थिति पर वास्तविक समय प्रतिक्रिया प्रदान करने के लिए प्रगति ट्रैकिंग लागू करें।

• रुकावटों और रद्दीकरणों को संभालना:
  जानें कि एक या सभी चल रहे डाउनलोड को शालीनतापूर्वक कैसे रद्द किया जाए।

नोट: यह ट्यूटोरियल केवल मुख्य डाउनलोडिंग लॉजिक पर ध्यान केंद्रित करेगा।

पर्यावरण सेटअप

कुछ भी करने से पहले भविष्य में संभावित बग से बचने के लिए अपने वातावरण को ठीक से स्थापित करना सुनिश्चित करें।

आवश्यक शर्तें

• इंस्टॉल करें
• AIR ऑटो रीलोडिंग के लिए
• जटिल कमांड चलाने के लिए फ़ाइल बनाएं
• Goose PostgreSQL माइग्रेशन के लिए

मेकफ़ाइल कॉन्फ़िगर करना

निम्नलिखित के साथ प्रोजेक्ट के मूल में एक मेकफ़ाइल बनाएं।

# 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

उच्च-स्तरीय फ़ोल्डर संरचना अवलोकन

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

पर्यावरण चर सेट करना

रूट में एक .env फ़ाइल बनाएं या पर्यावरण चर को अपनी इच्छानुसार संभालें, हम joho/godotenv पैकेज का उपयोग करेंगे।

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

एक वेब सर्वर बनाना

अब हम वेब सर्वर बनाना शुरू करेंगे जो आने वाले सभी अनुरोधों को संभालेगा।

सावधान रहें! इस गाइड का मुख्य भाग यहां से शुरू होता है। गोता लगाने के लिए तैयार हो जाइए!

एपीआई परत

शुरू करने के लिए, एपीआई फ़ोल्डर एपीआई.गो और रूट.गो के अंदर निम्नलिखित फ़ाइलें बनाएं

रूट.गो फ़ाइल सेटअप

सभी एपीआई रूट को यहां परिभाषित किया जाएगा। हम एक न्यूराउटर संरचना बनाते हैं जो एनवी कॉन्फ़िगरेशन लेती है, जिससे सभी मार्गों और हैंडलरों को पर्यावरण चर तक पहुंचने की अनुमति मिलती है।

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

api.go फ़ाइल सेटअप

यहां, हम सर्वर शुरू करने से पहले सभी आवश्यक मिडलवेयर, जैसे CORS और लॉगिंग, जोड़ देंगे।

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

मुख्य प्रवेश बिंदु

यह main.go फ़ाइल में मुख्य पैकेज है जो संपूर्ण के लिए एक प्रवेश बिंदु के रूप में कार्य करेगा।

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

    log.Fatal(s.Start())
}

यह सर्वर शुरू करने और उसका परीक्षण करने के लिए पर्याप्त है।

सर्वर प्रारंभ करें

air

इतना ही।?

परीक्षण

curl http://localhost:3000/healthcheck

स्थिति 200 के साथ प्रतिक्रिया ठीक होनी चाहिए

एक प्रदाता स्टोर बनाना

यदि आवश्यक हो तो हमें कई क्लाउड प्रदाताओं के लिए समर्थन जोड़ने के लिए एक स्केलेबल समाधान लागू करने की आवश्यकता है।

प्रदाता रजिस्ट्री पर कार्य कर रहा हूँ

// 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 हमारे सभी OAuth प्रदाताओं को रखने के लिए एक केंद्रीय मानचित्र के रूप में कार्य करती है। जब हम अपने प्रदाताओं को आरंभ करते हैं, तो हम उन्हें इस मानचित्र में पंजीकृत करेंगे। यह हमें हमारी संपूर्ण सेवा में किसी भी पंजीकृत प्रदाता की कार्यप्रणाली तक आसानी से पहुंचने की अनुमति देता है।

आप यह कार्रवाई बाद में देखेंगे।

प्रदाता स्टोर प्रारंभ करना

हम प्रदान किए गए पर्यावरण चर के आधार पर अपने प्रदाताओं को पंजीकृत करेंगे।

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
}

पूर्ण लेख पढ़ें।

ऊपर लपेटकर

हमने गो में Google ड्राइव डाउनलोडर के लिए आधार तैयार कर लिया है, जिसमें परियोजना संरचना स्थापित करने, Google OAuth को संभालने और भविष्य के विस्तार की नींव रखने जैसे प्रमुख घटकों को शामिल किया गया है। रास्ते में, हमने कुछ महत्वपूर्ण विषयों पर चर्चा की:

• सुचारू और स्केलेबल डेटा प्रबंधन सुनिश्चित करने के लिए Goose के साथ डेटाबेस माइग्रेशन।
• भविष्य में अतिरिक्त क्लाउड स्टोरेज प्रदाताओं के लिए आसानी से समर्थन बढ़ाने के लिए एक प्रदाता रजिस्ट्री का निर्माण।
• एक लचीली वास्तुकला डिजाइन करना जो भविष्य में अधिक जटिल तर्क को संभालना आसान बनाती है।

यह एक पोस्ट के लिए पर्याप्त से अधिक है, क्योंकि चीजें काफी लंबी होती जा रही थीं! हम अपना काम खत्म करने के लिए भाग 2 में वापस आएंगे, जहां हम मुख्य डाउनलोडिंग कार्यक्षमता पर काम करेंगे।

तब तक, बेझिझक मेरे GitHub में वर्तमान कार्यान्वयन का पता लगाएं और अगले चरणों के लिए बने रहें। हैप्पी डाउनलोडिंग!