This content originally appeared on DEV Community and was authored by Maksim

Будуємо надійні інтеграції з ігровими провайдерами: Посібник для Go-розробника

У світі онлайн-ігор швидкість, надійність та безпека є ключовими. Забезпечення безперебійного досвіду для гравців часто вимагає інтеграції з численними ігровими провайдерами — постачальниками ігор (слотів, настільних ігор, спортивних ставок тощо). Ця стаття дослідить архітектурні виклики та найкращі практики інтеграції та управління ігровими провайдерами, з особливим акцентом на розробку на Go.

Чому інтеграція з провайдерами є складною?

Кожен провайдер має свій унікальний API, протоколи та бізнес-логіку. Інтеграція з одним провайдером може бути простою, але управління десятками або сотнями створює значну складність:

Різноманітність API: REST, SOAP, різні формати даних (JSON, XML).
Синхронізація балансів: Забезпечення цілісності фінансових транзакцій.
Безпека: Захист від несанкціонованих дій.
Відмовостійкість: Обробка збоїв та затримок.
Масштабованість: Здатність системи обробляти зростаюче навантаження.

Саме тут Go, завдяки своїй продуктивності, конкурентності та чіткій архітектурі, стає ідеальним вибором.

Типи ігрових провайдерів: Seamless та Transfer

Існує два основні підходи до інтеграції ігрових провайдерів, які суттєво впливають на архітектуру вашої системи:

1. Seamless (Безшовні) Провайдери

У моделі “seamless” гравець взаємодіє з ігровим провайдером, але всі фінансові транзакції (дебет/кредит, перевірка балансу) обробляються на стороні оператора (вашої системи).

Як це працює:

Коли гравець запускає гру, провайдер робить запити до вашого бекенду для отримання балансу, списання ставки або нарахування виграшу.
Ваша система виступає “джерелом істини” для балансу гравця.

Go-контекст:
Ваша Go-система повинна мати публічний HTTP-сервер, який слухає вхідні запити від провайдерів. Вам потрібно реалізувати кінцеві точки (endpoints) для:

GET /balance: Повертає поточний баланс гравця.
POST /debit: Списує кошти з балансу гравця.
POST /credit: Нараховує кошти на баланс гравця.
POST /rollback: Відкочує транзакцію.

Ці endpoints повинні бути швидкими, надійними та безпечними. Ви будете інтенсивно використовувати net/http для обробки запитів, encoding/json для парсингу даних та вашу логіку роботи з базою даних для оновлення балансів.

2. Transfer (З переказом) Провайдери

У моделі “transfer” кошти гравця фізично переміщуються з вашого гаманця на гаманець провайдера, коли він починає грати в їхні ігри, і повертаються, коли він виходить з гри.

Як це працює:

Коли гравець запускає гру, ваша система робить запит до API провайдера для “депозиту” коштів на ігровий рахунок провайдера.
Коли гравець виходить з гри, ваша система робить запит до API провайдера для “виводу” залишку коштів назад у ваш гаманець.

Go-контекст:
Ваша Go-система тут виступає HTTP-клієнтом. Вам потрібно буде інтенсивно використовувати пакет net/http для здійснення вихідних запитів до API провайдерів. Важливо керувати станом переказів (наприклад, “очікує на депозит”, “завершено”, “помилка виведення”), оскільки це можуть бути тривалі операції, які вимагають механізмів відмов та повторів.

Webhook Endpoints та Callback Handling

Webhooks (або callbacks) є хребтом безшовних інтеграцій та важливим компонентом для сповіщень у моделях з переказом. Це механізм, за допомогою якого провайдер асинхронно повідомляє вашу систему про події (наприклад, зміну балансу гравця, завершення транзакції).

Go-контекст:
Ви створюєте HTTP-сервер, який слухає ці події.

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

// IncomingWebhookPayload represents a generic structure for a webhook payload
type IncomingWebhookPayload struct {
    TransactionID string `json:"transaction_id"`
    PlayerID      string `json:"player_id"`
    Amount        float64 `json:"amount"`
    Action        string `json:"action"` // e.g., "debit", "credit"
    Signature     string `json:"signature"` // For security validation
    // Add other fields as per provider's spec
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodPost {
        http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
        return
    }

    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Error reading request body", http.StatusInternalServerError)
        return
    }

    // 1. Signature Validation (Crucial!)
    isValid := validateSignature(body, r.Header.Get("X-Provider-Signature"), "your-secret-key")
    if !isValid {
        log.Printf("Webhook: Invalid signature for payload: %s", string(body))
        http.Error(w, "Invalid Signature", http.StatusUnauthorized)
        return
    }

    var payload IncomingWebhookPayload
    if err := json.Unmarshal(body, &payload); err != nil {
        log.Printf("Webhook: Error unmarshaling payload: %v, body: %s", err, string(body))
        http.Error(w, "Bad Request", http.StatusBadRequest)
        return
    }

    log.Printf("Received webhook: %+v", payload)

    // 2. Process the event asynchronously (e.g., publish to a message queue)
    go func() {
        // In a real system, you'd push this to a Kafka/RabbitMQ queue
        // for processing by another service, or use a goroutine pool.
        processTransaction(payload)
    }()

    // Respond quickly to the provider
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, `{"status": "success", "message": "Webhook received"}`)
}

func processTransaction(p IncomingWebhookPayload) {
    // Simulate async processing
    log.Printf("Processing transaction %s for player %s, amount %f", p.TransactionID, p.PlayerID, p.Amount)
    // Implement your database updates, business logic here
}

func main() {
    http.HandleFunc("/provider/webhook", webhookHandler)
    log.Println("Webhook server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

// Placeholder for signature validation - actual implementation below
func validateSignature(payload []byte, signature string, secret string) bool {
    // This will be implemented in the next section
    return true
}

Важливо: Ваші webhook endpoints повинні відповідати якомога швидше (HTTP 200 OK), щоб уникнути повторних спроб з боку провайдера. Саму бізнес-логіку слід виконувати асинхронно, наприклад, через черги повідомлень (Kafka, RabbitMQ) або окремі Go-рутини з пулом workers.

Signature Validation (HMAC, RSA)

Безпека є критично важливою. Зловмисник може спробувати відправити фальшиві webhook-и, щоб сфальсифікувати транзакції. Валідація підпису гарантує, що запит дійсно надійшов від легітимного провайдера і не був змінений.

1. HMAC (Hash-based Message Authentication Code)

HMAC використовує спільний секретний ключ, відомий як вам, так і провайдеру.
Провайдер обчислює хеш тіла запиту (або його частини) за допомогою секретного ключа і відправляє його в заголовку. Ви робите те саме і порівнюєте хеші.

Go-контекст:
Використовуйте пакети crypto/hmac, crypto/sha256 та encoding/hex.

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "log"
)

// validateHMACSignature validates an HMAC signature against a given payload and secret.
func validateHMACSignature(payload []byte, signature string, secretKey []byte) bool {
    mac := hmac.New(sha256.New, secretKey)
    mac.Write(payload)
    expectedMAC := mac.Sum(nil)

    // Compare the hex-encoded expected MAC with the received signature string
    return hex.EncodeToString(expectedMAC) == signature
}

func main() {
    payload := []byte(`{"transaction_id":"tx123","player_id":"p456","amount":100.0,"action":"debit"}`)
    secret := []byte("super-secret-provider-key")

    // Simulate provider generating signature
    mac := hmac.New(sha256.New, secret)
    mac.Write(payload)
    generatedSignature := hex.EncodeToString(mac.Sum(nil))

    log.Printf("Generated Signature: %s", generatedSignature)

    // Simulate your system validating signature
    isValid := validateHMACSignature(payload, generatedSignature, secret)
    log.Printf("HMAC Signature Valid: %t", isValid)

    // Test with a tampered payload
    tamperedPayload := []byte(`{"transaction_id":"tx123","player_id":"p456","amount":200.0,"action":"debit"}`)
    isValidTampered := validateHMACSignature(tamperedPayload, generatedSignature, secret)
    log.Printf("HMAC Signature Valid (tampered payload): %t", isValidTampered) // Should be false
}

2. RSA (Public Key Cryptography)

RSA використовує пару ключів: приватний ключ (відомий тільки провайдеру) та публічний ключ (який ви отримуєте від провайдера). Провайдер підписує дані своїм приватним ключем, а ви верифікуєте підпис його публічним ключем. Це більш надійний метод, оскільки вам не потрібно обмінюватися секретами.

Go-контекст:
Використовуйте пакети crypto/rsa, crypto/x509, crypto/sha256, encoding/base64 та encoding/pem.

package main

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "errors"
    "fmt"
    "log"
)

// LoadRSAPublicKey loads an RSA public key from a PEM encoded string.
func LoadRSAPublicKey(pemEncodedPub string) (*rsa.PublicKey, error) {
    block, _ := pem.Decode([]byte(pemEncodedPub))
    if block == nil {
        return nil, errors.New("failed to parse PEM block containing the public key")
    }
    pub, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return nil, fmt.Errorf("failed to parse DER encoded public key: %w", err)
    }
    rsaPub, ok := pub.(*rsa.PublicKey)
    if !ok {
        return nil, errors.New("public key is not of RSA type")
    }
    return rsaPub, nil
}

// ValidateRSASignature validates an RSA PSS signature against a payload using a public key.
func ValidateRSASignature(payload []byte, signatureBase64 string, publicKey *rsa.PublicKey) bool {
    hashed := sha256.Sum256(payload)

    signature, err := base64.StdEncoding.DecodeString(signatureBase64)
    if err != nil {
        log.Printf("Error decoding base64 signature: %v", err)
        return false
    }

    err = rsa.VerifyPSS(publicKey, crypto.SHA256, hashed[:], signature, nil)
    if err != nil {
        log.Printf("RSA signature verification failed: %v", err)
        return false
    }
    return true
}

func main() {
    // --- Example: Key generation (do NOT do this in production for validation) ---
    // For demonstration, usually you get the public key from the provider.
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        log.Fatalf("Failed to generate private key: %v", err)
    }
    publicKey := &privateKey.PublicKey

    // Encode public key to PEM format (as provider would give it to you)
    pubASN1, err := x509.MarshalPKIXPublicKey(publicKey)
    if err != nil {
        log.Fatalf("Failed to marshal public key: %v", err)
    }
    pubPEM := string(pem.EncodeToMemory(&pem.Block{
        Type:  "PUBLIC KEY",
        Bytes: pubASN1,
    }))
    log.Printf("Public Key PEM:\n%s", pubPEM)
    // --- End Example ---

    // Load public key (in a real app, this would be loaded from config/file)
    loadedPublicKey, err := LoadRSAPublicKey(pubPEM)
    if err != nil {
        log.Fatalf("Failed to load public key: %v", err)
    }

    payload := []byte(`{"transaction_id":"tx456","player_id":"p789","amount":50.0,"action":"credit"}`)

    // Simulate provider signing the payload
    hashed := sha256.Sum256(payload)
    signatureBytes, err := rsa.SignPSS(rand.Reader, privateKey, crypto.SHA256, hashed[:], nil)
    if err != nil {
        log.Fatalf("Failed to sign payload: %v", err)
    }
    generatedSignature := base64.StdEncoding.EncodeToString(signatureBytes)

    log.Printf("Generated RSA Signature (Base64): %s", generatedSignature)

    // Simulate your system validating signature
    isValid := ValidateRSASignature(payload, generatedSignature, loadedPublicKey)
    log.Printf("RSA Signature Valid: %t", isValid)

    // Test with a tampered payload
    tamperedPayload := []byte(`{"transaction_id":"tx456","player_id":"p789","amount":100.0,"action":"credit"}`)
    isValidTampered := ValidateRSASignature(tamperedPayload, generatedSignature, loadedPublicKey)
    log.Printf("RSA Signature Valid (tampered payload): %t", isValidTampered) // Should be false
}

Retry Mechanism для Failed Callbacks/Outgoing Requests

Мережеві збої, тимчасова недоступність провайдера або помилки обробки — це реальність. Ваша система повинна бути здатною повторно відправити запит або обробити callback, якщо перша спроба не вдалася.

Стратегії повторних спроб:

Exponential Backoff: Збільшення затримки між повторними спробами (наприклад, 1с, 2с, 4с, 8с).
Jitter: Додавання невеликої випадкової затримки, щоб уникнути “thundering herd” проблеми, коли багато клієнтів одночасно повторюють спробу.
Max Retries: Обмеження загальної кількості спроб.
Max Elapsed Time: Обмеження загального часу, протягом якого можуть відбуватися повторні спроби.

Go-контекст:

Використовуйте time.Sleep для затримок.
context.Context для скасування операцій.
Рекомендовані бібліотеки:
- github.com/cenkalti/backoff/v4: Дуже потужна і гнучка бібліотека для реалізації експоненціального відкату з підтримкою контексту.

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/cenkalti/backoff/v4"
)

// mockProviderCall simulates an API call to a provider that might fail.
// It succeeds on the 3rd attempt.
func mockProviderCall(attempt int) error {
    if attempt < 3 {
        log.Printf("Attempt %d: Provider call failed.", attempt)
        return fmt.Errorf("provider unavailable (attempt %d)", attempt)
    }
    log.Printf("Attempt %d: Provider call succeeded!", attempt)
    return nil
}

func main() {
    operation := func() error {
        // This counter is not thread-safe if used across multiple goroutines,
        // but fine for a single retry loop.
        mockProviderCallAttempt++
        return mockProviderCall(mockProviderCallAttempt)
    }

    // Create an exponential backoff policy
    expBackoff := backoff.NewExponentialBackOff()
    expBackoff.InitialInterval = 500 * time.Millisecond // Start with 500ms
    expBackoff.MaxInterval = 5 * time.Second            // Max delay between retries
    expBackoff.MaxElapsedTime = 30 * time.Second        // Total time to retry before giving up

    log.Println("Starting reliable provider call...")

    ctx, cancel := context.WithTimeout(context.Background(), 1 * time.Minute) // Overall operation timeout
    defer cancel()

    err := backoff.Retry(operation, backoff.WithContext(expBackoff, ctx))
    if err != nil {
        log.Fatalf("Operation failed after multiple retries: %v", err)
    } else {
        log.Println("Operation completed successfully!")
    }
}

var mockProviderCallAttempt = 0 // Global counter for simulation

Провайдер Адаптери (Adapter Pattern)

З великою кількістю провайдерів ви швидко зіткнетеся з проблемою “зовнішніх API-подібностей”, де кожен провайдер робить одне й те саме (отримати баланс, дебетувати, кредитувати), але різними способами. Паттерн “Адаптер” дозволяє стандартизувати взаємодію.

Go-контекст:
Go-інтерфейси є ідеальним інструментом для реалізації цього паттерну.

package main

import (
    "fmt"
    "log"
)

// GameProvider defines the common interface for all game providers.
type GameProvider interface {
    GetBalance(userID string) (float64, error)
    DebitBalance(userID string, amount float64, transactionID string) error
    CreditBalance(userID string, amount float64, transactionID string) error
    LaunchGame(gameID, userID string) (string, error) // Returns launch URL
}

// --- Specific Provider Implementations ---

// ProviderAClient represents the client for a hypothetical Provider A.
type ProviderAClient struct {
    APIKey string
    // ... other provider-specific fields
}

// NewProviderAClient creates a new client for Provider A.
func NewProviderAClient(apiKey string) *ProviderAClient {
    return &ProviderAClient{APIKey: apiKey}
}

// GetBalance implements the GameProvider interface for Provider A.
func (p *ProviderAClient) GetBalance(userID string) (float64, error) {
    log.Printf("ProviderA: Fetching balance for %s using API Key %s", userID, p.APIKey)
    // Simulate API call to Provider A
    return 150.75, nil
}

// DebitBalance implements the GameProvider interface for Provider A.
func (p *ProviderAClient) DebitBalance(userID string, amount float64, transactionID string) error {
    log.Printf("ProviderA: Debiting %f from %s (TxID: %s)", amount, userID, transactionID)
    // Simulate API call to Provider A
    return nil
}

// CreditBalance implements the GameProvider interface for Provider A.
func (p *ProviderAClient) CreditBalance(userID string, amount float64, transactionID string) error {
    log.Printf("ProviderA: Crediting %f to %s (TxID: %s)", amount, userID, transactionID)
    // Simulate API call to Provider A
    return nil
}

// LaunchGame implements the GameProvider interface for Provider A.
func (p *ProviderAClient) LaunchGame(gameID, userID string) (string, error) {
    log.Printf("ProviderA: Generating launch URL for game %s, user %s", gameID, userID)
    return fmt.Sprintf("https://provider-a.com/launch?game=%s&user=%s&token=xyz", gameID, userID), nil
}

// ProviderBClient represents the client for a hypothetical Provider B.
type ProviderBClient struct {
    ClientID     string
    ClientSecret string
    // ... other provider-specific fields
}

// NewProviderBClient creates a new client for Provider B.
func NewProviderBClient(clientID, clientSecret string) *ProviderBClient {
    return &ProviderBClient{ClientID: clientID, ClientSecret: clientSecret}
}

// GetBalance implements the GameProvider interface for Provider B.
func (p *ProviderBClient) GetBalance(userID string) (float64, error) {
    log.Printf("ProviderB: Querying balance for user %s with ClientID %s", userID, p.ClientID)
    // Simulate API call to Provider B (might use different auth/payload)
    return 200.00, nil
}

// DebitBalance implements the GameProvider interface for Provider B.
func (p *ProviderBClient) DebitBalance(userID string, amount float64, transactionID string) error {
    log.Printf("ProviderB: Performing transaction for %f from %s (TxID: %s)", amount, userID, transactionID)
    // Simulate API call to Provider B
    return nil
}

// CreditBalance implements the GameProvider interface for Provider B.
func (p *ProviderBClient) CreditBalance(userID string, amount float64, transactionID string) error {
    log.Printf("ProviderB: Refunding %f to %s (TxID: %s)", amount, userID, transactionID)
    // Simulate API call to Provider B
    return nil
}

// LaunchGame implements the GameProvider interface for Provider B.
func (p *ProviderBClient) LaunchGame(gameID, userID string) (string, error) {
    log.Printf("ProviderB: Requesting game session for game %s, player %s", gameID, userID)
    return fmt.Sprintf("https://provider-b.net/play?session_key=abc&game=%s&player=%s", gameID, userID), nil
}

func main() {
    // Our system interacts with providers via the common interface
    var providerA GameProvider = NewProviderAClient("providerA-secret-key")
    var providerB GameProvider = NewProviderBClient("providerB-client-id", "providerB-client-secret")

    // Example usage
    playerID := "player123"
    gameID := "slot-galaxy"

    // Using Provider A
    balanceA, err := providerA.GetBalance(playerID)
    if err == nil {
        fmt.Printf("Player %s balance on Provider A: %.2f\n", playerID, balanceA)
        providerA.DebitBalance(playerID, 10.0, "tx-a-1")
        launchURL_A, _ := providerA.LaunchGame(gameID, playerID)
        fmt.Printf("Launch URL for Provider A: %s\n\n", launchURL_A)
    }

    // Using Provider B
    balanceB, err := providerB.GetBalance(playerID)
    if err == nil {
        fmt.Printf("Player %s balance on Provider B: %.2f\n", playerID, balanceB)
        providerB.CreditBalance(playerID, 5.0, "tx-b-1")
        launchURL_B, _ := providerB.LaunchGame(gameID, playerID)
        fmt.Printf("Launch URL for Provider B: %s\n", launchURL_B)
    }
}

Це дозволяє вашій основній бізнес-логіці працювати з GameProvider інтерфейсом, не знаючи деталей реалізації конкретного провайдера.

Версіонування API Провайдерів

Провайдери регулярно оновлюють свої API. Без стратегії версіонування оновлення можуть бути руйнівними.

Популярні стратегії:

URL Path: /v1/balance, /v2/balance. Найпростіший і найпоширеніший.
Header Versioning: Використання заголовка Accept (наприклад, Accept: application/vnd.provider.v1+json).
Query Parameters: /balance?api-version=1. Менш поширений для REST.

Go-контекст:

Роутери: Використовуйте гнучкі роутери, такі як Gorilla Mux або chi, для визначення маршрутів на основі версій в URL.
Адаптери: Ваш адаптер може мати логіку для виклику різних версій API провайдера.

// Example with Gorilla Mux
package main

import (
    "fmt"
    "net/http"
    "log"

    "github.com/gorilla/mux"
)

func v1Handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from API v1!")
}

func v2Handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from API v2! New features available.")
}

func main() {
    r := mux.NewRouter()

    r.HandleFunc("/api/v1/data", v1Handler).Methods("GET")
    r.HandleFunc("/api/v2/data", v2Handler).Methods("GET")

    log.Println("Starting API server on :8080")
    log.Fatal(http.ListenAndServe(":8080", r))
}

Моніторинг здоров’я провайдерів

Постійний моніторинг є життєво важливим для раннього виявлення проблем з інтеграцією.

Що моніторити:

Latency (затримка): Час відповіді на запити до провайдера.
Error Rates (рівень помилок): Кількість помилок (HTTP 5xx, тайм-аути) від провайдера.
Uptime (час безвідмовної роботи): Чи доступний провайдер взагалі.
Business Metrics: Чи успішно обробляються транзакції.

Go-контекст:

Prometheus: Використовуйте клієнтські бібліотеки Prometheus (github.com/prometheus/client_golang/prometheus) для експорту метрик з вашої Go-програми.
Custom Health Checks: Реалізуйте /health або /metrics endpoints у вашому сервісі.
Логування: Структуровані логи (наприклад, за допомогою zap або logrus) для швидкого пошуку помилок.
Горутини: Запускайте окремі горутини, які періодично виконують “пінги” або “спроби транзакцій” з провайдерами для перевірки їхнього стану.

Fallback стратегії

Навіть з повторними спробами та моніторингом, провайдери можуть стати недоступними на тривалий час. Вам потрібні стратегії на випадок збою.

Приклади стратегій:

Circuit Breakers (Автоматичні вимикачі): Якщо провайдер часто виходить з ладу, “вимикач” може відкритися, негайно відхиляючи запити до провайдера на певний період, щоб дати йому час відновитися і не витрачати ресурси на невдалі запити.
Graceful Degradation: Замість повного збою, надайте гравцеві обмежений досвід (наприклад, не відображати ігри від проблемного провайдера).
Кешування: Кешуйте баланси або інші дані, щоб забезпечити хоч якусь відповідь, якщо провайдер недоступний.
Альтернативні провайдери: У дуже критичних випадках, можливо, переключитися на іншого провайдера для певних типів ігор.

Go-контекст:

Circuit Breakers: Використовуйте бібліотеки, такі як sony/gobreaker або afex/hystrix-go.
Context with Timeout: Встановлюйте тайм-аути для всіх вихідних HTTP-запитів, щоб уникнути зависань.

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/sony/gobreaker" // Circuit Breaker library
)

// Mock API Call that can fail
func callExternalService(ctx context.Context) (string, error) {
    // Simulate network delay or failure
    select {
    case <-ctx.Done():
        return "", ctx.Err() // Context cancelled or timed out
    case <-time.After(100 * time.Millisecond): // Simulate a fast response
        // For demonstration, let's make it fail sometimes
        if time.Now().Second()%5 == 0 { // Fails every 5th second
            return "", fmt.Errorf("external service failed")
        }
        return "Success from external service!", nil
    }
}

func main() {
    // Configure the circuit breaker
    st := gobreaker.Settings{
        Name:        "ProviderService",
        MaxRequests: 3,                 // Allow 3 requests when in Half-Open state
        Interval:    5 * time.Second,   // Reset counts every 5 seconds
        Timeout:     10 * time.Second,  // Time to wait before attempting to close
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            // Trip the circuit if 60% of requests are failures, and we have at least 10 requests
            return counts.Requests >= 10 && float64(counts.Failure) / float64(counts.Requests) >= 0.6
        },
        OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
            log.Printf("Circuit Breaker '%s' changed from %s to %s", name, from, to)
        },
    }
    cb := gobreaker.NewCircuitBreaker(st)

    // Simulate repeated calls to the external service
    for i := 0; i < 50; i++ {
        ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
        defer cancel()

        result, err := cb.Execute(func() (interface{}, error) {
            return callExternalService(ctx)
        })

        if err != nil {
            log.Printf("Call %d: Failed - %v", i+1, err)
        } else {
            log.Printf("Call %d: Successful - %s", i+1, result)
        }
        time.Sleep(200 * time.Millisecond) // Wait a bit between calls
    }
}

Висновок

Інтеграція та управління ігровими провайдерами — це складна, але надзвичайно важлива задача для будь-якого розробника в iGaming індустрії. Використовуючи потужні можливості Go (інтерфейси, горутини, пакети net/http, crypto, context), а також перевірені архітектурні патерни (адаптери, retry-механізми, circuit breakers), ви можете побудувати надійну, безпечну та масштабовану систему.

Пам’ятайте, що успішна інтеграція — це не лише написання коду, а й розуміння бізнес-вимог, ретельне тестування та постійний моніторинг.

Щасливого кодування на Go!

go #golang #gamedev #apiintegration #microservices #systemdesign #webhooks #security #adapterpattern #resilience #circuitbreaker #monitoring

This content originally appeared on DEV Community and was authored by Maksim