Verwenden größerer Runner

Übersicht über larger runner

Neben den in GitHub gehosteten Standardrunnern bietet GitHub Kunden mit den GitHub Team- und GitHub Enterprise Cloud-Plänen auch eine Auswahl von larger runnern mit mehr RAM und CPU an. Diese Runner werden von GitHub gehostet und verfügen über eine Vorinstallation der Runneranwendung und anderer Tools.

Wenn larger runner für deine Organisation aktiviert sind, wird automatisch eine standardmäßige Runnergruppe erstellt, die vier vorkonfigurierte larger runner enthält.

Wenn du einer Organisation einen larger runner hinzufügst, definierst du einen Computertyp aus einer Auswahl verfügbarer Hardwarespezifikationen und Betriebssystemimages. GitHub erstellt dann mehrere Instanzen dieses Runners, die im Rahmen der von dir definierten Grenzwerte für die automatische Skalierung hoch- und herunterskaliert werden können, um den Anforderungen deiner Organisation zu entsprechen.

Computerspezifikationen für larger runner

Größe (vCPU)	Arbeitsspeicher (GB)	Speicher (SSD)
4 Kerne	16 RAM	150 GB
8 Kerne	32 RAM	300 GB
16 Kerne	64 RAM	600 GB
32 Kerne	128 RAM	1.200GB
64 Kerne	256 RAM	2040 GB

Architekturübersicht über larger runner

Die larger runner werden auf Organisationsebene verwaltet, wobei sie in Gruppen angeordnet werden, die mehrere Instanzen des Runners enthalten können. Sie können auch auf Unternehmensebene erstellt und für Organisationen in der Hierarchie freigegeben werden. Sobald du eine Gruppe erstellt hast, kannst du der Gruppe einen Runner hinzufügen und deine Workflows so aktualisieren, dass sie entweder auf den Gruppennamen oder die Bezeichnung abzielen, die dem larger runner zugewiesen ist. Du kannst auch steuern, welche Repositorys Aufträge zur Verarbeitung an die Gruppe senden dürfen. Weitere Informationen zu Gruppen findest du unter Steuern des Zugriffs auf larger runner.

Im folgenden Diagramm wurde eine Klasse gehosteter Runner namens ubuntu-20.04-16core mit benutzerdefinierter Hardware und Betriebssystemkonfiguration definiert.

1. Instanzen dieses Runners werden automatisch erstellt und einer Gruppe namens grp-ubuntu-20.04-16core hinzugefügt.
2. Den Runnern wurde die Bezeichnung ubuntu-20.04-16core zugewiesen.
3. Workflowaufträge verwenden die Bezeichnung ubuntu-20.04-16core in ihrem runs-on Schlüssel, um den Typ des Runners anzugeben, den sie zum Ausführen des Auftrags benötigen.
4. GitHub Actions überprüft die Runnergruppe, um festzustellen, ob dein Repository zum Senden von Aufträgen an den Runner autorisiert ist.
5. Der Auftrag wird in der nächsten verfügbaren Instanz des ubuntu-20.04-16core-Runners ausgeführt.

Automatische Skalierung von larger runnern

Deine larger runner lassen sich so konfigurieren, dass sie automatisch deinen Anforderungen entsprechend skaliert werden können. Wenn Aufträge zur Verarbeitung übermittelt werden, können für die Auftragsausführung automatisch mehr Computer bereitgestellt werden, bis ein vordefinierter Höchstwert erreicht wird. Jeder Computer verarbeitet immer nur einen Auftrag, sodass diese Einstellungen effektiv die Anzahl der Aufträge festlegen, die gleichzeitig ausgeführt werden können.

Während des Runnerbereitstellungsvorgangs kannst du durch Konfiguration der Option Max deine Kosten kontrollieren, indem du die maximale parallele Anzahl von Computern festlegst, die in dieser Gruppe erstellt werden. Durch einen höheren Wert kann die Blockierung von Workflows aufgrund paralleler Vorgänge vermieden werden.

Netzwerkbetrieb für larger runner

Standardmäßig erhalten larger runner eine dynamische IP-Adresse, die sich für jede Auftragsausführung ändert. Optional können GitHub Enterprise Cloud-Kunden ihre larger runner so konfigurieren, dass diese eine statische IP-Adresse aus dem IP-Adresspool von GitHub erhalten. Wenn diese Option aktiviert ist, erhalten Instanzen der larger runner eine Adresse aus einem für den Runner eindeutigen Bereich, sodass du anhand dieses Bereichs eine Firewallpositivliste konfigurieren kannst. Du kannst insgesamt bis zu 10 statische IP-Adressbereiche für alle deine larger runner verwenden.

Planung für larger runner

Erstellen einer Runnergruppe

Runnergruppen werden verwendet, um Gruppen von VMs zu sammeln und um sie herum eine Sicherheitsgrenze zu erstellen. Anschließend kannst du entscheiden, welche Organisationen oder Repositorys Aufträge auf diesen Computergruppen ausführen dürfen. Während des Bereitstellungsvorgangs für larger runner kann der Runner einer vorhandenen Gruppe hinzugefügt werden, andernfalls wird er in einer Standardgruppe aufgenommen. Du kannst eine Gruppe erstellen, indem du die Schritte unter Steuern des Zugriffs auf larger runner ausführst.

Grundlegendes zur Abrechnung

Im Vergleich zu in standardmäßigen, GitHub gehosteten Runnern werden larger runner anders abgerechnet. Weitere Informationen findest du unter Minutentarife.

Hinzufügen eines larger runners zu einem Unternehmen

Du kannst larger runner einem Unternehmen hinzufügen, in dem sie mehreren Organisationen zugewiesen werden können. Anschließend können die Organisationsadministratoren steuern, von welchen Repositorys die Runner verwenden werden können. Um einem Unternehmen einen larger runner hinzufügen zu können, musst du ein Unternehmensbesitzer sein.

Du kannst ein Betriebssystem und eine Hardwarekonfiguration aus der Liste der verfügbaren Optionen auswählen. Wenn neue Instanzen dieses Runners über die automatische Skalierung bereitgestellt werden, verwenden sie dasselbe Betriebssystem und dieselbe Hardwarekonfiguration, die du hier festgelegt hast.

Du kannst außerdem die Bezeichnungen festlegen, die den Runner identifizieren. So können deine Workflows (mit runs-on) Aufträge zur Verarbeitung an die Runner übermitteln. Neue Runner werden automatisch der Standardgruppe zugewiesen. Alternativ kannst du beim Erstellen der Runner auswählen, welcher Gruppe die Runner beitreten sollen. Außerdem kannst du die Gruppenmitgliedschaft der Runner ändern, nachdem du die Runner registriert hast. Weitere Informationen findest du unter Steuern des Zugriffs auf larger runner.

1. Klicke in der Unternehmensrandleiste auf Richtlinien. 1. Klicke unter „ Richtlinien“ auf Aktionen. 1. Klicke auf die Registerkarte Runner. 1. Klicke auf Neuer Runner und dann auf Neuer von GitHub gehosteter Runner.

2. Fülle die erforderlichen Angaben aus, um deinen neuen Runner zu konfigurieren:

   • Name: Gib einen Namen für deinen neuen Runner ein. Zur leichteren Identifizierung sollten hier die Hardware und die Betriebskonfiguration angegeben werden, z. B. ubuntu-20.04-16core.
   • Runnerimage: Wähle ein Betriebssystem aus den verfügbaren Optionen. Sobald du ein Betriebssystem ausgewählt hast, kannst du eine spezifische Version auswählen.
   • Runnergröße: Wähle in der Dropdownliste der verfügbaren Optionen eine Hardwarekonfiguration aus.
   • Automatische Skalierung: Wähle die maximale Anzahl von Runnern aus, die zu jedem Zeitpunkt aktiv sein können.
   • Runnergruppe: Wähle die Gruppe aus, der dein Runner angehören soll. Diese Gruppe hostet mehrere Instanzen deines Runners, die je nach Bedarf hoch- und herunterskaliert werden können.
   • Netzwerk: Nur für GitHub Enterprise Cloud: Wähle aus, ob den Instanzen des larger runner ein statischer IP-Adressbereich zugewiesen werden soll. Du kannst insgesamt bis zu 10 statische IP-Adressen verwenden.

3. Klicke auf Runner erstellen.

4. Um Organisationen den Zugriff auf deine larger runner zu ermöglichen, gib die Liste der Organisationen an, die sie verwenden können. Weitere Informationen findest du unter Verwalten des Zugriffs auf deine Runner.

Hinzufügen eines larger runners zu einer Organisation

Du kannst einen larger runner einer Organisation hinzufügen, in der die Organisationsadministratoren steuern, von welchen Repositorys er verwendet werden kann.

Du kannst ein Betriebssystem und eine Hardwarekonfiguration aus der Liste der verfügbaren Optionen auswählen. Wenn neue Instanzen dieses Runners über die automatische Skalierung bereitgestellt werden, verwenden sie dasselbe Betriebssystem und dieselbe Hardwarekonfiguration, die du hier festgelegt hast.

Du kannst außerdem die Bezeichnungen festlegen, die den Runner identifizieren. So können deine Workflows (mit runs-on) Aufträge zur Verarbeitung an die Runner übermitteln. Neue Runner werden automatisch der Standardgruppe zugewiesen. Alternativ kannst du beim Erstellen der Runner auswählen, welcher Gruppe die Runner beitreten sollen. Außerdem kannst du die Gruppenmitgliedschaft der Runner ändern, nachdem du die Runner registriert hast. Weitere Informationen findest du unter Steuern des Zugriffs auf larger runner.

1. Navigiere auf GitHub.com zur Hauptseite der Organisation. 1. Klicke unter deinem Organisationsnamen auf Einstellungen. 1. Klicke in der linken Seitenleiste auf Aktionen, und klicke dann auf Runner. 1. Klicke auf Neuer Runner und dann auf Neuer von GitHub gehosteter Runner.

2. Fülle die erforderlichen Angaben aus, um deinen neuen Runner zu konfigurieren:

   • Name: Gib einen Namen für deinen neuen Runner ein. Zur leichteren Identifizierung sollten hier die Hardware und die Betriebskonfiguration angegeben werden, z. B. ubuntu-20.04-16core.
   • Runnerimage: Wähle ein Betriebssystem aus den verfügbaren Optionen. Sobald du ein Betriebssystem ausgewählt hast, kannst du eine spezifische Version auswählen.
   • Runnergröße: Wähle in der Dropdownliste der verfügbaren Optionen eine Hardwarekonfiguration aus.
   • Automatische Skalierung: Wähle die maximale Anzahl von Runnern aus, die zu jedem Zeitpunkt aktiv sein können.
   • Runnergruppe: Wähle die Gruppe aus, der dein Runner angehören soll. Diese Gruppe hostet mehrere Instanzen deines Runners, die je nach Bedarf hoch- und herunterskaliert werden können.
   • Netzwerk: Nur für GitHub Enterprise Cloud: Wähle aus, ob den Instanzen des larger runner ein statischer IP-Adressbereich zugewiesen werden soll. Du kannst insgesamt bis zu 10 statische IP-Adressen verwenden.

3. Klicke auf Runner erstellen.

4. Um einem Repository den Zugriff auf deine larger runner zu ermöglichen, füge es der Liste der Repositorys hinzu, die die Runner verwenden können. Weitere Informationen findest du unter Verwalten des Zugriffs auf deine Runner.

Ausführen von Aufträgen in deinem Runner

Sobald dein Runnertyp definiert wurde, kannst du deine Workflow-YAML-Dateien aktualisieren, um Aufträge zur Verarbeitung an deine neu erstellten Runnerinstanzen zu senden. Du kannst Runnergruppen oder Bezeichnungen verwenden, um festzulegen, wo deine Aufträge ausgeführt werden.

Nur Besitzer- oder Administratorkonten können die Runnereinstellungen einsehen. Benutzer ohne Administratorrechte können sich an den Organisationsadministrator wenden, um herauszufinden, welche Runner aktiviert sind. Dein Organisationsadministrator kann neue Runner und Runnergruppen erstellen sowie Berechtigungen konfigurieren, um festzulegen, welche Repositorys auf eine Runnergruppe zugreifen können.

Verwenden von Gruppen zum Steuern, wo Aufträge ausgeführt werden

In diesem Beispiel wurden Ubuntu 16-Core-Runner zu einer Gruppe namens ubuntu-runners hinzugefügt. Der runs-on-Schlüssel sendet den Auftrag an einen beliebigen verfügbaren Runner in der Gruppe ubuntu-runners:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on: 
      group: ubuntu-runners
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Verwenden von Bezeichnungen zum Steuern, wo Aufträge ausgeführt werden

In diesem Beispiel wird eine Runnergruppe mit Ubuntu 16-Core Runnern aufgefüllt, denen ebenfalls die Bezeichnung ubuntu-20.04-16core zugewiesen wurde. Der Schlüssel runs-on sendet den Auftrag an alle verfügbaren Runner mit einer zutreffenden Bezeichnung:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on:
      labels: ubuntu-20.04-16core
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Verwenden von Bezeichnungen und Gruppen zum Steuern, wo Aufträge ausgeführt werden

Wenn du Gruppen und Bezeichnungen kombinierst, muss der Runner beide Anforderungen erfüllen, um zum Ausführen des Auftrags berechtigt zu sein.

In diesem Beispiel wird eine Runnergruppe namens ubuntu-runners mit Ubuntu 16-Core-Runnern aufgefüllt, denen zudem die Bezeichnung ubuntu-20.04-16core zugewiesen wurde. Der runs-on-Schlüssel kombiniert group und labels, sodass der Auftrag an einen beliebigen verfügbaren Runner innerhalb der Gruppe weitergeleitet wird, der auch eine übereinstimmende Bezeichnung aufweist:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on:
      group: ubuntu-runners
      labels: ubuntu-20.04-16core
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Verwenden mehrerer Bezeichnungen

Du kannst mehrere Bezeichnungen angeben, die abgeglichen werden müssen, damit ein Auftrag in einem Runner ausgeführt werden kann. Ein Runner muss alle Bezeichnungen abgleichen, um den Auftrag ausführen zu können.

In diesem Beispiel muss ein Runner alle drei Bezeichnungen abgleichen, um den Auftrag auszuführen:

name: learn-github-actions
on: [push]
jobs:
  check-bats-version:
    runs-on:
      labels: [ ubuntu-20.04-16core, gpu, qa ]
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '14'
      - run: npm install -g bats
      - run: bats -v

Verwalten des Zugriffs auf deine Runner

Anhand von Runnergruppen wird gesteuert, welche Repositorys Aufträge in deinen larger runnern ausführen können. Du musst den Zugriff auf die Gruppe aus jeder Ebene der Verwaltungshierarchie gewähren, je nachdem, wo du den larger runner definiert hast:

• Runner auf Unternehmensebene: Konfiguriere die Runnergruppe, um Zugriff auf alle erforderlichen Organisationen zu gewähren. Darüber hinaus musst du für jede Organisation die Gruppe konfigurieren und angeben, welchen Repositorys der Zugriff gestattet wird.
• Runner auf Organisationsebene: Konfiguriere die Runnergruppe, indem du angibst, welchen Repositorys der Zugriff gestattet wird.

Das folgende Diagramm zeigt beispielsweise eine Runnergruppe namens grp-ubuntu-20.04-16core auf Unternehmensebene. Bevor das Repository namens octo-repo die Runner in der Gruppe verwenden kann, musst du die Gruppe zuerst auf Unternehmensebene konfigurieren, um den Zugriff aus der Organisation octo-org zu ermöglichen. Anschließend musst du die Gruppe auf Organisationsebene konfigurieren, um den Zugriff aus octo-repo zu erlauben:

Gewähren des Zugriffs auf eine Runnergruppe für Repositorys

In diesem Verfahren wird veranschaulicht, wie du Gruppenberechtigungen auf Unternehmens- und Organisationsebene konfigurierst:

1. Navigiere zur Hauptseite des Repositorys oder der Organisation, in dem bzw. der sich deine Runnergruppen befinden.
2. Klicke auf Einstellungen.
3. Klicke in der linken Seitenleiste auf Aktionen, und klicke dann auf Runner-Gruppen. 1. Klicke in der Liste der Gruppen auf die Runnergruppe, die du konfigurieren möchtest.

• Für Runnergruppen in einem Unternehmen: Ändere unter Organisationszugriff die Organisationen, die auf die Runnergruppe zugreifen können.
• Für Runnergruppen in einer Organisation: Ändere unter Repositoryzugriff die Repositorys, die auf die Runnergruppe zugreifen können.