Skip to main content

Limitaciones de recursos

La API de GraphQL de GitHub cuenta con limitaciones para la protección contra las llamadas excesivas o abusivas a los servidores de GitHub.

Límite de nodos

Para pasar la validación del esquema, todas las llamadas de GraphQL API deben cumplir estos estándares:

  • Los clientes deben proporcionar un argumento first o last en cualquier conexión.
  • Los valores de first y last deben estar comprendidos entre 1 y 100.
  • Las llamadas individuales no pueden solicitar más de un total de 500 000 nodos.

Calcular los nodos en una llamada

Estos dos ejemplos te muestran cómo calcular los nodos totales en una llamada.

  1. Consulta simple:

    query {
      viewer {
        repositories(first: 50) {
          edges {
            repository:node {
              name
    
              issues(first: 10) {
                totalCount
                edges {
                  node {
                    title
                    bodyHTML
                  }
                }
              }
            }
          }
        }
      }
    }

    Cálculo:

    50         = 50 repositories
     +
    50 x 10  = 500 repository issues
    
                = 550 total nodes
  2. Consulta compleja:

    query {
      viewer {
        repositories(first: 50) {
          edges {
            repository:node {
              name
    
              pullRequests(first: 20) {
                edges {
                  pullRequest:node {
                    title
    
                    comments(first: 10) {
                      edges {
                        comment:node {
                          bodyHTML
                        }
                      }
                    }
                  }
                }
              }
    
              issues(first: 20) {
                totalCount
                edges {
                  issue:node {
                    title
                    bodyHTML
    
                    comments(first: 10) {
                      edges {
                        comment:node {
                          bodyHTML
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
    
        followers(first: 10) {
          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

Límite de frecuencia

El límite de GraphQL API es diferente de los límites de frecuencia de la API REST.

¿Por qué son diferentes los límites de tasa de la API? Con GraphQL, una llamada a GraphQL puede reemplazar varias llamadas REST. Una sola llamada compleja de GraphQL puede ser el equivalente a miles de solicitudes de REST. Si bien una sola llamada de GraphQL caería muy debajo del límite de tasa de la API de REST, la consulta podría ser igual de cara en términos de procesamiento para los servidores de GitHub.

Para representar con precisión el costo de una consulta al servidor, GraphQL API calcula la puntuación de límite de frecuencia de una llamada en función de una escala de puntos normalizada. Los factores de puntuación de una consulta en argumentos "firs" y "last" en una conexión padre y sus hijos.

  • La fórmula utiliza los argumentos first y last en una conexión primaria y en sus secundarias para calcular previamente la carga potencial en los sistemas de GitHub, tales como MySQL, ElasticSearch y Git.
  • Cada conexión nueva tiene su propio valor de puntos. Los puntos se combinan con otros puntos desde la llamada en una puntuación de tasa límite general.

El límite de frecuencia de GraphQL API es de 5000 puntos por hora.

Ten en cuenta que 5000 puntos por hora no es lo mismo que 5000 llamadas por hora: GraphQL API y la API REST utilizan límites de frecuencia diferentes.

Nota: La fórmula y el límite de frecuencia actuales están sujetos a cambios mientras observamos cómo los desarrolladores utilizan GraphQL API.

Recuperar el estado de límite de tasa de una llamada

Con la API REST, puedes revisar el estado del límite de frecuencia inspeccionando los encabezados HTTP devueltos.

Con GraphQL API, puedes comprobar el estado del límite de frecuencia consultando campos del objeto rateLimit:

query {
  viewer {
    login
  }
  rateLimit {
    limit
    cost
    remaining
    resetAt
  }
}
  • El campo limit devuelve el número máximo de puntos que se permite consumir al cliente en un periodo de 60 minutos.

  • El campo cost devuelve el costo en puntos para la llamada actual que cuenta con respecto al límite de tasa.

  • El campo remaining devuelve la cantidad de puntos restantes en el periodo de límite de tasa actual.

  • El campo resetAt devuelve la hora a la que se restablece la ventana de límite de tasa actual en segundos UTC.

Calcular el puntaje de límite de tasa antes de ejecutar la llamada

Al consultar el objeto rateLimit, se devuelve la puntuación de una llamada, pero ejecutar la llamada cuenta con respecto al límite. Para evitar este dilema, puedes calcular el puntaje de una llamada antes de ejecutarla. Los cálculos siguientes funcionan casi de la misma manera que el costo que devuelve rateLimit { cost }.

  1. Agrega la cantidad de solicitudes requeridas para completar cada conexión única en la llamada. Suponga que todas las solicitudes alcanzarán los límites de argumentos first o last.
  2. Divida la cantidad entre 100 y redondee el resultado para obtener el costo final agregado. Este paso normaliza las cantidades grandes.

Nota: El costo mínimo de una llamada a GraphQL API es 1, que representa una única solicitud.

Aquí se muestra una consulta y cálculo de puntaje de ejemplo:

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

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

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

Esta consulta requiere de 5,101 solicitudes para completarse:

  • Aunque se devuelven 100 repositorios, la API se tiene que conectarse a la cuenta del visor una vez para obtener la lista de repositorios. Por lo tanto, las solicitudes de repositorios = 1
  • Aunque se devuelven 50 incidencias, la API tiene que conectarse a cada uno de los 100 repositorios para obtener la lista de problemas. Por lo tanto, solicitudes de problemas = 100
  • Aunque se devuelven 60 etiquetas, la API tiene que conectarse a cada uno de los 5000 problemas potenciales totales para obtener la lista de etiquetas. Por lo tanto, solicitudes de etiquetas = 5000
  • Total = 5101

Si lo dividimos entre 100 y lo redondeamos, obtenemos la puntuación final de la consulta: 51.