Skip to main content

Einrichten von Dependabot für die Ausführung auf selbst gehosteten Aktionsrunnern mit dem Actions Runner Controller

Du kannst den Actions Runner Controller so konfigurieren, dass Dependabot auf selbstgehosteten Runnern ausgeführt wird.

Wer kann dieses Feature verwenden?

Benutzer*innen mit Schreibzugriff

Arbeiten mit dem Actions Runner Controller (ARC)

Dieser Artikel enthält Schrittanleitungen zum Einrichten von ARC auf einem Kubernetes-Cluster und zum Konfigurieren von Dependabot für die Ausführung auf selbstgehosteten Aktionsrunnern. Der Artikel enthält Folgendes:

  • Er enthält eine Übersicht über die ARC- und Dependabot-Integration.
  • Er enthält detaillierte Installations- und Konfigurationsschritte mithilfe von Helm-Skripts.

Was ist ARC?

Der Actions Runner Controller ist ein Kubernetes-Controller, der selbstgehostete GitHub Actions als Kubernetes-Pods verwaltet. Er ermöglicht es, Runner basierend auf deinen Workflows dynamisch zu skalieren und zu koordinieren und eine bessere Ressourcenauslastung und Integration in Kubernetes-Umgebungen zu ermöglichen. Weitere Informationen findest du unter Actions Runner Controller (Steuerung für Aktionsläufer).

Dependabot auf ARC

Du kannst Dependabot auf selbstgehosteten GitHub Actions-Runnern ausführen, die innerhalb eines Kubernetes-Clusters über ARC verwaltet werden. Dies ermöglicht die automatische Skalierung, Workloadisolation und eine bessere Ressourcenverwaltung für Dependabot-Aufträge, wodurch sichergestellt wird, dass Abhängigkeitsupdates effizient in der kontrollierten Infrastruktur einer Organisation ausgeführt und gleichzeitig nahtlos in GitHub Actions integriert werden können.

Einrichten von ARC für Dependabot in der lokalen Umgebung

Voraussetzungen

  • Ein Kubernetes-Cluster
    • Für eine verwaltete Cloudumgebung kannst du Azure Kubernetes Service (AKS) verwenden.
    • Für ein lokales Setup kannst du minikube verwenden.
  • Helm
    • Ein Paket-Manager für Kubernetes.

Einrichten von ARC

  1. Installiere ARC. Weitere Informationen finden Sie unter Schnellstart für Actions Runner Controller.

  2. Erstelle ein Arbeitsverzeichnis für das ARC-Setup und eine Shell-Skriptdatei (z. B. helm_install_arc.sh), um die neueste ARC-Version zu installieren.

    Bash
        mkdir ARC
        touch helm_install_arc.sh
        chmod 755 helm_install_arc.sh
    
  3. Bearbeite helm_install_arc.sh mit diesem Bash-Skript zum Installieren von ARC.

    Text
    NAMESPACE="arc-systems"
    helm install arc \
        --namespace "${NAMESPACE}" \
        --create-namespace \
        oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set-controller
    
  4. Führe die Skriptdatei helm_install_arc.sh aus.

    ./helm_install_arc.sh
    
  5. Jetzt musst du den Skalierungssatz für den Runner konfigurieren. Beginnen wir damit, eine Datei mit dem folgenden Bash-Skript zu erstellen und zu bearbeiten.

    Bash
    touch arc-runner-set.sh
    chmod 755 arc-runner-set.sh
    
    Text
    INSTALLATION_NAME="dependabot"
    NAMESPACE="arc-runners"
    GITHUB_CONFIG_URL=REPO_URL
    GITHUB_PAT=PAT
    helm install "${INSTALLATION_NAME}" \
        --namespace "${NAMESPACE}" \
        --create-namespace \
        --set githubConfigUrl="${GITHUB_CONFIG_URL}" \
        --set githubConfigSecret.github_token="${GITHUB_PAT}" \
        --set containerMode.type="dind" \
        oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set
    
  6. Führe die Skriptdatei arc-runner-set.sh aus.

    Bash
    ./arc-runner-set.sh
    

Hinweis

  • Der Installationsname des Runner-Scale-Sets muss dependabot sein, um den Dependabot-Job auf den Runner auszurichten.
  • Die containerMode.type="dind"-Konfiguration ist erforderlich, damit der Runner eine Verbindung mit dem Docker-Daemon herstellen kann.
  • Wenn ein Runner auf Organisationsebene oder Unternehmensebene erstellt wird, sollten die entsprechenden Berechtigungen dem Personal Access Token (PAT) zugewiesen werden.
  • Es kann ein personal access token (classic) (PAT) erstellt werden. Das Token sollte über die folgenden Bereiche verfügen, je nachdem, ob du ein Repository, eine Organisation oder ein Runner-Skalierungsset auf Unternehmensebene erstellst.

Hinzufügen von Runner-Gruppen

Mit Runnergruppen kann gesteuert werden, welche Organisationen oder Repositories Zugriff auf Runner-Skalierungsgruppen haben. Damit du einer Runnergruppe eine Runner-Skalierungsgruppe hinzufügen kannst, musst du bereits eine Runnergruppe erstellt haben.

Informationen zum Erstellen von Runnergruppen findest du unter Verwalten des Zugriffs auf selbstgehostete Runner mithilfe von Gruppen.

Vergiss nicht, die folgende Einstellung zur Konfiguration des Skalierungssets für die Runner im Helm-Chart hinzuzufügen.

Text
--set runnerGroup="<Runner group name>" \

Überprüfen der Installation

  1. Überprüfe deine Installation.

    Bash
    helm list -A
    

    Ausgabe:

    ➜  ARC git:(master) ✗ helm list -A
        NAME           NAMESPACE   REVISION UPDATED                              STATUS   CHART                                  APP VERSION
        arc            arc-systems 1        2025-04-11 14:41:53.70893 -0500 CDT  deployed gha-runner-scale-set-controller-0.11.0 0.11.0
        arc-runner-set arc-runners 1        2025-04-11 15:08:12.58119 -0500 CDT  deployed gha-runner-scale-set-0.11.0            0.11.0
        dependabot     arc-runners 1        2025-04-16 21:53:40.080772 -0500 CDT deployed gha-runner-scale-set-0.11.0
    
  2. Überprüfe den Manager-Pod mit diesem Befehl.

    Bash
    kubectl get pods -n arc-systems
    

    Ausgabe:

    ➜  ARC git:(master) ✗ kubectl get pods -n arc-systems
    
    NAME                                    READY   STATUS    RESTARTS      AGE
    arc-gha-rs-controller-57c67d4c7-zjmw2   1/1     Running   8 (36h ago)   6d9h
    arc-runner-set-754b578d-listener        1/1     Running   0             11h
    dependabot-754b578d-listener            1/1     Running   0             14h
    

Einrichten von Dependabot

  1. Erstelle eine Organisation in GitHub Enterprise Server. Weitere Informationen finden Sie unter Eine neue Organisation von Grund auf erstellen.
  2. Erstelle eine Runnergruppe. Siehe Hinzufügen von Runnergruppen.
  3. Aktiveren Sie das Abhängigkeitsdiagramm aus der Verwaltungskonsole. Weitere Informationen findest du unter Aktivieren des Abhängigkeitsdiagramms für dein Unternehmen.
  4. Aktiviere GitHub Connect für dein Unternehmen. Weitere Informationen findest du unter Aktivieren von GitHub Connect für GitHub.com.
  5. Aktiviere Dependabot alerts für das Unternehmen. Weitere Informationen findest du unter Aktivieren von Dependabot für dein Unternehmen.

Auslösen einer Dependabot-Ausführung

Nachdem du ARC eingerichtet hast, kannst du eine Dependabot-Ausführung starten.

  1. Navigieren Sie auf GitHub zur Hauptseite des Repositorys.

  2. Klicke unter dem Repositorynamen auf die Registerkarte Insights.

  3. Klicke auf der linken Randleiste auf Abhängigkeitsdiagramm.

    Screenshot der Registerkarte Abhängigkeitsdiagramm. Die Registerkarte ist mit einer orangefarbenen Kontur hervorgehoben.

  4. Klicke unter „Abhängigkeitsdiagramm“ auf Dependabot .

  5. Klicke rechts neben dem Namen der relevanten Manifestdatei auf Recent update jobs.

  6. Wenn keine kürzlichen Aktualisierungsaufträge für die Manifestdatei vorhanden sind, klicke auf Check for updates, um einen Dependabot-Versionsupdateauftrag erneut auszuführen und nach neuen Updates für Abhängigkeiten für dieses Ökosystem zu suchen.

Anzeigen der generierten ARC-Runner

Du kannst die ARC-Runner anzeigen, die für den Dependabot-Auftrag erstellt wurden.

  1. Navigieren Sie auf GitHub zur Hauptseite des Repositorys.

  2. Klicke unter dem Repositorynamen auf Actions.

    Screenshot: Registerkarten für das Repository „github/docs“. Die Registerkarte „Aktionen“ ist mit einem orangefarbenen Rahmen hervorgehoben.

  3. Klicke auf der linken Randleiste auf Runners.

  4. Klicke unter „Runners“ auf Self-hosted runners, um eine Liste aller im Repository verfügbaren Läufer anzuzeigen. Du siehst den kurzlebigen Dependabot-Runner, der erstellt wurde.

           ![Screenshot mit einem Dependabot-Runner in der Liste der verfügbaren Runner. Der Läufer ist mit einer orangefarbenen Umrandung hervorgehoben.](/assets/images/help/dependabot/dependabot-self-hosted-runner.png)
    

    Sie können denselben Dependabot-Runner-Pod, der in Ihrem Kubernetes-Cluster erstellt wurde, auch im Terminal anzeigen, indem Sie diesen Befehl ausführen.

    Text
    ➜  ARC git:(master) ✗ kubectl get pods -n arc-runners
        NAME                            READY   STATUS    RESTARTS   AGE
        dependabot-sw8zn-runner-4mbc7   2/2     Running   0          46s
    

Darüber hinaus kannst du Folgendes überprüfen:

  • Die Protokolle, durch Überprüfen des Runner- und Computernamens Weitere Informationen findest du unter Anzeigen von Dependabot-Auftragsprotokollen.

    Beispiel eines Protokolls für einen selbstgehosteten Dependabot-Runner

  • Die Pull Requests für Versionsupdates, die durch den Dependabot-Auftrag erstellt wurden (auf der Registerkarte Pull requests des Repositorys)