# Gerenciamento de limites de requisições de API

O Bate-papo do Copilot pode ajudar a lidar com os limites de taxa de solicitação da API sugerindo código que detecta esses limites e implementa a lógica de repetição.

Ao fazer solicitações para APIs, é comum encontrar limites de taxa que restringem o número de chamadas que você pode fazer em um determinado período. O Copilot Chat do GitHub pode ajudar você a tratar esses limites sugerindo código para detectar respostas de limite de taxa e repetir solicitações automaticamente após um atraso.

## Cenário de exemplo

O código Python a seguir busca dados meteorológicos de uma API externa. Se a API tiver limites de taxa, as solicitações poderão falhar quando os limites forem excedidos, e seu aplicativo poderá precisar de uma maneira de lidar com essas respostas normalmente implementando a lógica de repetição.

```python id=rate-limit-example
from flask import Flask, request
import requests

app = Flask(__name__)

WEATHER_API_URL = "https://api.example.com/weather"

@app.route('/get_weather', methods=['GET'])
def get_weather():
    city = request.args.get('city')
    # Simulate an API request to the external weather service
    response = requests.get(WEATHER_API_URL, params={"city": city})
    weather_data = response.json()

    return weather_data
```

## Solicitação de exemplo

```copilot copy prompt ref=rate-limit-example
How can I handle API rate limits within get_weather().
```

## Exemplo de resposta

> \[!NOTE] A resposta a seguir é um exemplo. Respostas do Bate-papo do Copilot são não determinísticas, portanto, você pode obter uma resposta diferente da mostrada aqui.

O Copilot pode sugerir código que implementa um mecanismo de repetições com backoff exponencial para limitar a frequência das tentativas de repetição.

Por exemplo:

```python
import requests
from flask import Flask, request
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

app = Flask(__name__)

WEATHER_API_URL = "https://api.example.com/weather"

def requests_retry_session(
    retries=3,
    backoff_factor=0.3,
    status_forcelist=(500, 502, 504),
    session=None,
):
    session = session or requests.Session()
    retry = Retry(
        total=retries,
        read=retries,
        connect=retries,
        backoff_factor=backoff_factor,
        status_forcelist=status_forcelist,
    )
    adapter = HTTPAdapter(max_retries=retry)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    return session

@app.route('/get_weather', methods=['GET'])
def get_weather():
    city = request.args.get('city')
    try:
        response = requests_retry_session().get(WEATHER_API_URL, params={"city": city})
        response.raise_for_status()
        weather_data = response.json()
    except requests.exceptions.RequestException as e:
        return {"error": str(e)}, 500

    return weather_data
```

Neste exemplo, o Copilot inclui a configuração de uma sessão de repetição para que o código possa repetir automaticamente as solicitações se elas falharem devido a códigos de status específicos (500, 502, 504). O `backoff_factor` aumenta gradualmente o atraso entre novas tentativas, ajudando a evitar exceder ainda mais o limite da taxa da API.

## Leitura adicional

* [Engenharia de prompts para o GitHub Copilot Chat](/pt/copilot/using-github-copilot/prompt-engineering-for-github-copilot)
* [Práticas recomendadas para usar GitHub Copilot](/pt/copilot/using-github-copilot/best-practices-for-using-github-copilot)