Esta versão do GitHub Enterprise foi descontinuada em 2021-06-09. Nenhum lançamento de patch será feito, mesmo para questões críticas de segurança. Para obter melhor desempenho, melhorar a segurança e novos recursos, upgrade to the latest version of GitHub Enterprise. Para ajuda com a atualização, contact GitHub Enterprise support.

Limitações de recursos

A API do GraphQL de GitHub tem limitações de proteção contra chamadas excessivas ou abusivas para os servidores de GitHub.

Neste artigo

Limite de nó

Para passar a validação do esquema, todas as chamadas da API v4 do GraphQL devem atender a esses padrões:

  • Os clientes devem fornecer um primeiro ou último argumento conexão.
  • Os valores de primeiro e último devem ser entre 1 e 100.
  • As chamadas individuais não podem solicitar mais de 500.000 nósno total.

Calcular nós em uma chamada

Estes dois exemplos mostram como calcular os nós totais em uma chamada.

  1. Consulta simples:

    query {
    viewer {
    repositories(first: 50) {
    edges {
    repository:node {
    name

          issues(first: <span class="greenbox">10</span>) {
            totalCount
            edges {
              node {
                title
                bodyHTML
              }
            }
          }
        }
      }
    }
    

    } }

    Cálculo:

    50         = 50 repositories

    • 50 x 10 = 500 repository issues

              = 550 total nodes</pre>
      
  2. Consulta complexa:

    query {
    viewer {
    repositories(first: 50) {
    edges {
    repository:node {
    name

          pullRequests(first: <span class="greenbox">20</span>) {
            edges {
              pullRequest:node {
                title
    
                comments(first: <span class="bluebox">10</span>) {
                  edges {
                    comment:node {
                      bodyHTML
                    }
                  }
                }
              }
            }
          }
    
          issues(first: <span class="greenbox">20</span>) {
            totalCount
            edges {
              issue:node {
                title
                bodyHTML
    
                comments(first: <span class="bluebox">10</span>) {
                  edges {
                    comment:node {
                      bodyHTML
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
    
    followers(first: <span class="bluebox">10</span>) {
      edges {
        follower:node {
          login
        }
      }
    }
    

    } }

    Cálculo:

    50              = 50 repositories

    • 50 x 20 = 1,000 pullRequests

    • 50 x 20 x 10 = 10,000 pullRequest comments

    • 50 x 20 = 1,000 issues

    • 50 x 20 x 10 = 10,000 issue comments

    • 10 = 10 followers

                   = 22,060 total nodes</pre>
      

Limite de taxa

O limite de taxas do GraphQL API v4 é diferente dos limites de taxa do REST API v3.

Por que os limites de taxa de API são diferentes? Com o GraphQL, uma chamada do GraphQL pode substituir várias chamadas de REST. Uma chamada única e complexa do GraphQL poderia ser o equivalente a milhares de solicitações de REST. Embora uma única chamada GraphQL fique bem abaixo do limite de taxa de API REST, a consulta pode ser muito cara para os servidores do GitHub calcularem.

Para representar com precisão o custo de servidor de uma consulta, a API v4 do GraphQL calcula a pontuação de um limite de taxa de uma chamada com base em uma escala normalizada de pontos. Os fatores de pontuação de uma consulta no primeiro e último argumentos em uma conexão principal e suas conexões auxiliares.

  • A fórmula usa argumentos primeiros e último na conexão principal e nas conexões secundárias para pré-calcular o potencial de carga nos sistemas do GitHub, como MySQL, ElasticSearch e Git.
  • Cada nova conexão tem o seu valor próprio de pontos. Os pontos são combinados com outros pontos da chamada para uma pontuação de limite de taxa geral.

O limite de taxa de câmbio da API v4 do GraphQL é 5.000 pontos por hora.

Observe que 5.000 pontos por hora não é o mesmo que 5.000 chamadas por hora: a API v4 do GraphQL e a API v3 de REST usam diferentes limites de taxa.

Observação: A fórmula atual e o limite de taxa estão sujeitos a alterações à medida que observamos como os desenvolvedores usam a API v4 do GraphQL.

Retornar o status de limite da chamada

Com a API REST v3, você pode verificar o status do limite de taxa inspecionando os cabeçalhos HTTP retornados.

Com o GraphQL API v4, você pode verificar o status do limite de taxa consultando campos no objeto rateLimit:

query {
  viewer {
    login
  }
  rateLimit {
    limit
    cost
    remaining
    resetAt
  }
}
  • O campo limite retorna o número máximo de pontos que o cliente tem permissão para consumir em uma janela de 60 minutos.

  • O campo custo retorna o custo do ponto para a chamada atual que conta contra o limite de taxa.

  • O campo restante retorna o número de pontos restantes na janela de limite de taxa atual).

  • O campo resetAt retorna o tempo em que a janela de limite de taxa atual é redefinida em segundos de satélite de UTC.

Calcular um limite de taxa antes de executar a chamada

Consultar o objeto rateLimit retorna a pontuação de uma chamada, mas executar a chamada tem um custo para o limite. Para evitar esse dilema, você pode calcular a pontuação de uma chamada antes de executá-la. O cálculo a seguir funciona quase da mesma maneira que o que retorna taxteLimit { cost }.

  1. Adicione o número de solicitações necessárias para atender cada conexão única na chamada. Assuma que todas solicitações atingirão os limites de argumento primeiro ou último.
  2. Divida o número por 100 e arredonde o resultado para obter o custo agregado final. Esta etapa normaliza números grandes.

Observação: O custo mínimo de uma chamada para a API v4 do GraphQL é 1, o que representa uma única solicitação.

Aqui está um exemplo de consulta e cálculo de pontuação:

query {
  viewer {
    login
    repositories(first: 100) {
      edges {
        node {
          id

          issues(first: 50) {
            edges {
              node {
                id

                labels(first: 60) {
                  edges {
                    node {
                      id
                      name
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Esta consulta exige que 5,101 solicitações sejam atendidas:

  • Embora estejamos retornando 100 repositórios, a API tem que se conectar à conta do visualizador uma vez para obter a lista de repositórios. Portanto, solicitações para repositórios = 1
  • Embora estejamos retornando 50 problemas, a API tem que se conectar a cada um dos 100 repositórios para obter a lista de problemas. Portanto, solicitações para problemas = 100
  • Embora estejamos retornando 60 etiquetas, a API tem que se conectar a cada um dos 5.000 problemas potenciais totais para obter a lista de etiquetas. Portanto, solicitações de etiquetas = 5.000
  • Total = 5.101

Se dividirmos por 100 e arredondar, o resultado nos dará a pontuação final da consulta: 51