Rate Limiting em Swift: gerenciamento de frequência de requisições em iOS/macOS

Rate Limiting em Swift (iOS/macOS): Guia completo

Rate Limiting (limitação de frequência de requisições) é um mecanismo criticamente importante para o funcionamento estável de aplicativos móveis e de desktop. No ecossistema Swift (iOS/macOS), o gerenciamento correto da frequência de chamadas de API, envio de dados ou execução de tarefas em segundo plano previne a sobrecarga de servidores, economiza tráfego e protege contra abusos. Neste artigo, analisaremos detalhadamente as bibliotecas e ferramentas para implementar Rate Limiting em Swift, incluindo algoritmos, exemplos de código e melhores práticas.

Por que o Rate Limiting é importante para iOS/macOS?

Aplicativos para dispositivos Apple frequentemente interagem com servidores remotos: baixam conteúdo, sincronizam dados, enviam análises. Sem limitações:

• O servidor pode bloquear o aplicativo por exceder o limite (HTTP 429 Too Many Requests).
• A bateria do dispositivo descarrega rapidamente devido a chamadas de rede frequentes.
• A interface do usuário fica sem resposta com requisições em avalanche.

Principais algoritmos de Rate Limiting

Em Swift, três algoritmos clássicos são mais comumente usados:

• Token Bucket (Balde de tokens) — tokens são acumulados a uma taxa constante, cada requisição consome um token. Adequado para carga uniforme.
• Leaky Bucket (Balde furado) — as requisições são processadas a uma taxa fixa, as excessivas são descartadas ou colocadas em fila.
• Sliding Window (Janela deslizante) — contagem de requisições nos últimos N segundos/minutos. Flexível, mas requer mais memória.

Bibliotecas populares para Rate Limiting em Swift

1. Alamofire (mecanismos integrados)

Embora o Alamofire seja um cliente HTTP, ele fornece ferramentas para limitar requisições através de RequestInterceptor. Você pode criar seu próprio interceptador que verificará o número de requisições e adicionará atrasos.

import Alamofire

class RateLimiter: RequestInterceptor {    private let queue = DispatchQueue(label: "rate.limiter")    private var lastRequestTime: Date?    private let minimumInterval: TimeInterval = 1.0 // 1 segundo entre requisições        func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {        queue.sync {            if let last = lastRequestTime, Date().timeIntervalSince(last) < minimumInterval {                let delay = minimumInterval - Date().timeIntervalSince(last)                Thread.sleep(forTimeInterval: delay)            }            lastRequestTime = Date()        }        completion(.success(urlRequest))    }}

let session = Session(interceptor: RateLimiter())

2. SwiftyBeaver (registro com limitação)

Para limitar a frequência de logs, use SBPlatformDestination com a configuração minLevel e um filtro personalizado. Mas para um Rate Limiting completo, é melhor combinar com uma biblioteca separada.

3. RateLimit (biblioteca especializada)

A biblioteca de código aberto RateLimit (disponível via Swift Package Manager) implementa o algoritmo Token Bucket. Ela é leve e ideal para iOS/macOS.

import RateLimit

let limiter = TokenBucket(capacity: 10, fillRate: 1) // 10 requisições por segundo

func makeRequest() {    guard limiter.consume() else {        print("Limite de taxa excedido. Requisição bloqueada.")        return    }    // Execução da requisição de rede    print("Requisição enviada.")}

4. NetworkThrottle (ferramenta avançada)

A biblioteca NetworkThrottle é especializada em emular redes lentas e limitar a velocidade de requisições. Útil para testes e depuração.

import NetworkThrottle

let throttle = NetworkThrot