Ratenbegrenzungen und Abfragegrenzwerte für die GraphQL-API

Primäre Ratenbegrenzung

Ratenbegrenzungen sind bei GitHub Enterprise Server standardmäßig deaktiviert. Wende dich an deine Websiteadministrator*innen, um die Ratenlimits für deine Instanz zu bestätigen.

Wenn Sie ein Websiteadministrator sind, können Sie Ratenbegrenzungen für Ihre Instanz festlegen. Weitere Informationen finden Sie unter Configuring rate limits (Konfigurieren von Ratenbegrenzungen).

Wenn Sie eine App für Benutzer oder Organisationen außerhalb Ihrer Instanz entwickeln, gelten die standardmäßigen Ratenbegrenzungen für GitHub. Weitere Informationen findest du unter Ratenbegrenzungen und Abfragegrenzwerte für die GraphQL-API in der GitHub Free-Dokumentation.

Knotenlimit

Um die Schemaüberprüfung zu bestehen, müssen alle GraphQL-API-Aufrufe folgende Standards erfüllen:

• Clients müssen ein Argument first oder last für eine beliebige Verbindung angeben.
• Werte von first und last müssen innerhalb von 1-100 liegen.
• Einzelne Aufrufe können nicht mehr als 500.000 Knoten insgesamt anfordern.

Berechnen von Knoten in einem Aufruf

In diesen beiden Beispielen wird gezeigt, wie die Knoten insgesamt in einem Aufruf berechnet werden.

1. Einfache Abfrage:

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

   Berechnung:

   50         = 50 repositories
    +
   50 x 10  = 500 repository issues
   
               = 550 total nodes

2. Komplexe Abfrage:

   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
           }
         }
       }
     }
   }

   Berechnung:

   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

Strategien zur Abfrageoptimierung

• Anzahl der Objekte begrenzen: Verwende kleinere Werte für first- oder last-Argumente, und paginiere durch Ergebnisse.
• Abfragetiefe reduzieren: Vermeide es, tief geschachtelte Objekte anzufordern, es sei denn, es ist erforderlich.
• Ergebnisse filtern: Verwende Argumente, um Daten zu filtern und nur das zurückzugeben, was du benötigst.
• Große Abfragen aufteilen: Unterteile komplexe Abfragen in mehrere einfachere Abfragen.
• Nur erforderliche Felder anfordern: Wähle nur die benötigten Felder aus, anstatt alle verfügbaren Felder anzufordern.

Durch Befolgen dieser Strategien kannst du die Wahrscheinlichkeit verringern, dass Ressourcengrenzwerte erreicht werden, und die Leistung und Zuverlässigkeit deiner API-Anforderungen verbessern.