Använda registry-robotar från GitHub Actions och OpenShift

Din källkod och CI kan ligga kvar på GitHub, och dina kluster på OpenShift, medan paketen finns i din fremforge-organisation. Båda når registret via en registry-robot: en inloggning som hör till organisationen, inte till en person.

En registry-robot:

• läser, eller läser och publicerar, paketen i en organisation, av alla pakettyper;
• kan publicera men inte ta bort: att ta bort en paketversion, en fil, en container-tagg eller en image nekas med 403 och registreras i granskningsloggen som registry_robot.delete_refused. Borttagning är förbehållen en administratör i organisationen, i webbgränssnittet eller med sin egen inloggning;
• kan inte läsa kod, öppna webbgränssnittet eller nå någon annan organisation;
• räknas inte som användare;
• har ett slutdatum på högst 365 dagar, varefter den och alla dess token slutar fungera;
• listas, med vem som skapade den, under Organisationens administration → Säkerhet → Åtkomst → Registry-robotar, och varje skapande, rotation, borttagning och nekad borttagning av paket finns i organisationens granskningslogg.

I fremforges egen CI behöver du ingen: ett Forgejo Actions-jobb har redan en token för sin egen organisations paket. Se Publicera från Forgejo Actions.

Skapa en robot

I konsolen: Organisationens administration → Säkerhet → Åtkomst → Registry-robotar → Skapa en robot. Välj Läsa paket för en pull secret och Läsa och publicera paket (kan inte ta bort) för ett CI-jobb som publicerar.

Sidan visar sedan robotens användarnamn och token en gång. Kopiera båda; token visas inte igen. Om den går förlorad utfärdar Rotera token en ny och återkallar den gamla direkt.

Eller med API:t, med en API-token som har scopet policy:write:

curl -sS -X POST "https://frem.sh/_app/api/v1/orgs/<org>/registry-robots" \
  -H "Authorization: Bearer $FREMFORGE_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "github-publish", "access": "write", "expires_in_days": 90}'

Svaret innehåller username och token. access är read eller write, och expires_in_days är 1 till 365 (standard 90). Rotera med POST /orgs/<org>/registry-robots/<id>/rotate, eventuellt med {"expires_in_days": n} för att sätta ett nytt slutdatum, och ta bort med DELETE /orgs/<org>/registry-robots/<id>.

Användarnamnet har formen <org prefix>-fremforge-bot-reg-<8 hex characters>. Prefixet är din organisations namn, förkortat vid behov så att användarnamnet ryms inom 40 tecken: en robot i acme-infrastructure-team får ett namn som acme-infrastr-fremforge-bot-reg-1a2b3c4d. Kopiera användarnamnet som sidan eller API:t visar i stället för att bygga det av organisationens namn. Alla klienter nedan tar det som användarnamn och token som lösenord.

GitHub Actions

Spara roboten i GitHub-repot eller -organisationen: användarnamnet som variabeln FREMFORGE_REGISTRY_USER och token som secreten FREMFORGE_REGISTRY_TOKEN. Sätt ORG till din fremforge-organisation.

Container-images

- name: Push to fremforge
  env:
    FREMFORGE_USER: ${{ vars.FREMFORGE_REGISTRY_USER }}
    FREMFORGE_TOKEN: ${{ secrets.FREMFORGE_REGISTRY_TOKEN }}
    ORG: <org>
  run: |
    echo "$FREMFORGE_TOKEN" | docker login frem.sh -u "$FREMFORGE_USER" --password-stdin
    docker build -t "frem.sh/$ORG/app:$GITHUB_SHA" .
    docker push "frem.sh/$ORG/app:$GITHUB_SHA"

Hämta på samma sätt, med docker pull frem.sh/<org>/app:<tag>. En pushad tagg kan inte skrivas över när oföränderliga releaser är påslaget för organisationen.

npm

npm skickar bara en token till en registry-URL som matchar exakt, så ge det scopets registry och token för den URL:en:

- name: Publish to fremforge
  env:
    FREMFORGE_TOKEN: ${{ secrets.FREMFORGE_REGISTRY_TOKEN }}
    ORG: <org>
  run: |
    printf '@<scope>:registry=https://frem.sh/api/packages/%s/npm/\n//frem.sh/api/packages/%s/npm/:_authToken=%s\n' \
      "$ORG" "$ORG" "$FREMFORGE_TOKEN" > .npmrc
    npm publish

Samma .npmrc installerar @<scope>/…-paket med npm install.

PyPI

- name: Publish to fremforge
  env:
    FREMFORGE_USER: ${{ vars.FREMFORGE_REGISTRY_USER }}
    FREMFORGE_TOKEN: ${{ secrets.FREMFORGE_REGISTRY_TOKEN }}
    ORG: <org>
  run: |
    python -m pip install twine
    twine upload --repository-url "https://frem.sh/api/packages/$ORG/pypi" \
      -u "$FREMFORGE_USER" -p "$FREMFORGE_TOKEN" dist/*

Installera med robotens inloggningsuppgifter i index-URL:en:

pip install --index-url "https://$FREMFORGE_USER:$FREMFORGE_TOKEN@frem.sh/api/packages/$ORG/pypi/simple/" <package>

Maven

Lägg till en server med det id som din pom.xml använder för fremforge-repositoryt, och läs roboten från miljön:

<settings>
  <servers>
    <server>
      <id>fremforge</id>
      <username>${env.FREMFORGE_USER}</username>
      <password>${env.FREMFORGE_TOKEN}</password>
    </server>
  </servers>
</settings>

- name: Publish to fremforge
  env:
    FREMFORGE_USER: ${{ vars.FREMFORGE_REGISTRY_USER }}
    FREMFORGE_TOKEN: ${{ secrets.FREMFORGE_REGISTRY_TOKEN }}
  run: mvn --batch-mode -s .ci/settings.xml deploy

med repositoryt i pom.xml som i Maven: https://frem.sh/api/packages/<org>/maven.

Utan lagrad secret: GitHubs OIDC-token

En robot kan också ta emot GitHub Actions egen OIDC-token i stället för en lagrad registry-token. Ge roboten det numeriska id:t för din GitHub-organisation (eller -användare), och eventuellt ett repo, under GitHub Actions på roboten, eller med github_repository_owner_id och github_repository i API:t. Ett jobb hos den ägaren begär då sin OIDC-token med audience https://frem.sh/<org> (permissions: id-token: write) och byter den på POST https://frem.sh/_app/api/v1/registry/oidc-token (org, robot, id_token) mot robotens användarnamn och en token som gäller i 1 timme. Utbytet beskrivs i API-referensen under Registry robots; varje token det utfärdar finns i granskningsloggen med repot, ref:en och körningens id.

SBOM:er

SBOM:er går till fremforges API, inte till registret, med en API-token som har scopet sboms:write. Se Ladda upp SBOM:er från GitHub Actions.

OpenShift och Kubernetes

Hämta images från fremforge med en skrivskyddad robot som pull secret för images:

kubectl create secret docker-registry frem-sh \
  --docker-server=frem.sh \
  --docker-username=<robot username> \
  --docker-password=<robot token> \
  --namespace=<namespace>

och hänvisa till den från arbetslasten:

spec:
  imagePullSecrets:
    - name: frem-sh
  containers:
    - name: app
      image: frem.sh/<org>/app:1.4.2

OpenShift läser samma secret av typen kubernetes.io/dockerconfigjson. Rotera roboten innan den går ut och ersätt secreten med en som skapats från den nya token.

Värdar att släppa igenom en brandvägg för utgående trafik

En nedladdning av en annan paketfil än en container-image svarar 303 med en kortlivad signerad länk till filen i objektlagringen på obs.eu-de.otc.t-systems.com, som klienten följer. Det namnet är en CNAME för obs.lz01.eu-de.otc.t-systems.com, så en brandvägg som kontrollerar varje namn i kedjan behöver båda. Lager för container-images levereras av frem.sh själv.

frem.sh levereras via en CDN, så dess adresser ändras: tillåt den med namn, inte med IP-adress.

Beroendeproxy

En robot med läsåtkomst hämtar också via din organisations beroendeproxy (Docker Hub, npm, PyPI och de andra publika registren), med samma token. Se Autentisering.