MinIO: GitHub Actions ir GitLab CI

Paleiskite tikrą MinIO paslaugą iš savo GitHub Actions arba GitLab CI pipeline, vykdykite testus ir automatiškai viską uždarykite

👋 Sveiki atvykę į Stackhero dokumentaciją!

Stackhero siūlo paruoštą naudoti MinIO Object Storage sprendimą, kuris suteikia daugybę privalumų, įskaitant:

Neriboti perdavimai.

Paprasta, prognozuojama ir skaidri kainodara.

Pritaikomas domeno vardas, apsaugotas HTTPS (pavyzdžiui, https://object-storage.jusu-imone.com).

Lengvi atnaujinimai vienu paspaudimu.

Optimali veikla ir tvirta sauga, užtikrinama privačios ir dedikuotos VM.

Prieinama 🇪🇺 Europoje ir 🇺🇸 JAV.

Taupykite laiką ir supaprastinkite savo gyvenimą: tereikia 5 minučių, kad išbandytumėte Stackhero MinIO Object Storage hosting sprendimą!

Šiame vadove rasite, kaip CI pipeline aplinkoje paleisti dedikuotą, realią MinIO paslaugą naudojant GitHub Actions arba GitLab CI. Vadovaudamiesi šiais žingsniais, galėsite testuoti savo kodą prieš gyvą MinIO instanciją, kuri veikia sąlygomis, artimomis produkcinei aplinkai – nebereikės naudoti jokių imitacijų ar simuliacijų. MinIO is high-performance, S3-compatible object storage, so you get S3 semantics for your files without the S3 bill.

Kiekvieno pipeline paleidimo metu bus sukurta nauja MinIO instancija. Tai reiškia, kad jūsų testai bendraus su tokiu pačiu paslaugos tipu, kokį matys ir jūsų naudotojai produkcijoje. Darbo eiga automatiškai sukuria laikiną stack, prideda MinIO, laukia, kol paslauga bus paruošta, paima sugeneruotus prisijungimo duomenis, atlieka smoke testą naudodama the AWS CLI, o pabaigoje viską visada išvalo.

Naudosite Stackhero CLI – savarankišką komandų eilutės įrankį, kuris leidžia greitai ir paprastai paleisti bei valdyti Stackhero paslaugas.

1. Sukurkite prieigos raktą ir įrašykite jį kaip CI slaptą kintamąjį

Kad CLI galėtų veikti be interaktyvaus įsikišimo, jums reikės prieigos rakto (formatas: usr-xxxxxx:tokenId). Šį raktą reikia sukurti tik vieną kartą ir pridėti jį prie savo CI pipeline kaip saugų, užšifruotą slaptą kintamąjį.

Sukurkite raktą: Savo Stackhero valdymo skydelyje spauskite profilio nuotrauką viršuje dešinėje, eikite į Your account, tada Access tokens ir spauskite Create token.
GitHub Actions atveju: Savo repozitorijoje eikite į Settings > Secrets and variables > Actions > New repository secret ir įveskite raktą kaip STACKHERO_TOKEN.
GitLab CI atveju: Projekte eikite į Settings > CI/CD > Variables > Add variable, nustatykite raktą kaip STACKHERO_TOKEN ir pažymėkite Masked (bei Protected, jei CI vykdomas tik protected šakose).

Niekada nedėkite savo prieigos rakto tiesiai į pipeline YAML failą. Jei raktas bus YAML faile, jis gali būti matomas visiems, turintiems prieigą prie repozitorijos, ir gali atsirasti build loguose. Laikant jį kaip CI slaptą kintamąjį, raktas išlieka užšifruotas ir paslėptas, todėl jūsų saugumas išlieka užtikrintas.

2. Gyvavimo ciklo scenarijus

Žemiau pateiktas pilnas scenarijus, kuris valdo visą paslaugos gyvavimo ciklą. Matysite, kad reikia tik kelių komandų – galite kopijuoti paruoštą YAML savo platformai iš žemiau esančių skyrių.

#!/bin/bash
set -euo pipefail

# STACKHERO_TOKEN pateikiamas per CI slaptą kintamąjį, CLI jį automatiškai aptinka.

stackName="ci-minio-$$"          # Unikalus stack pavadinimas kiekvienam paleidimui
serviceStore="minio"             # MinIO paslaugos store
instance="100G"        # Pakeiskite jei reikia (žr. 3 žingsnį)
region="europe"                         # Regiono pavadinimas (žr. stackhero regions-list)

# 1. Įdiekite CLI runner'yje
curl -fsSL https://www.stackhero.io/install.sh | sh

# 2. Įdiekite klientą, reikalingą smoke testui (jq + curl yra baziniai)
apt-get update && apt-get install -y --no-install-recommends jq curl awscli

# 3. Sukurkite dedikuotą stack šiam paleidimui
stackId=$(stackhero --format=script stack-create --name="$stackName")
echo "Stack sukurtas: $stackId"

# 4. Pridėkite MinIO ir gaukite jo service id
serviceId=$(stackhero --format=script service-add \
  --stack="$stackId" \
  --service-store="$serviceStore" \
  --instance="$instance" \
  --region="$region")
echo "Paslauga pridėta: $serviceId"

# 5. Palaukite, kol paslauga bus paleista (gali užtrukti kelias minutes)
stackhero service-wait-for --service="$serviceId"

# 6. Perskaitykite konfigūraciją (joje yra sugeneruoti prisijungimo duomenys)
config=$(stackhero service-configuration-get --service="$serviceId" --format=json)

# 7. Ištraukite reikiamus prisijungimo duomenis
host=$(echo "$config" | jq -r '.configuration.domain')
accessKey=$(echo "$config" | jq -r '.configuration.credentials.rootUser')
secretKey=$(echo "$config" | jq -r '.configuration.credentials.rootPassword')

# 8. Smoke testas: List the buckets with the AWS CLI (S3-compatible).
AWS_ACCESS_KEY_ID="$accessKey" AWS_SECRET_ACCESS_KEY="$secretKey" \
  aws --endpoint-url "https://$host" s3 ls

echo "✅ MinIO pasiekiamas iš CI."

Teardown žingsnis, kuris ištrina paslaugą, laukia jos pašalinimo ir tada ištrina stack, aprašytas žemiau platformai skirtuose skyriuose. Tokiu būdu visada užtikrinamas išvalymas, net jei smoke testas nepavyksta.

Stack galima ištrinti tik tada, kai jis tuščias. Visada pirmiausia ištrinkite paslaugą ir palaukite jos pašalinimo, tada ištrinkite stack. Komanda service-wait-for užtikrina, kad paslauga būtų arba paleista, arba jau ištrinta prieš tęsiant, todėl ji tinkama ir laukimui ištrinant.

3. Pasirinkite instancijos dydį

Žemiau pateiktuose pavyzdžiuose pagal nutylėjimą naudojama pradinio lygio 100G instancija MinIO. Tai patikimas pasirinkimas daugumai užduočių, tačiau galite keisti pagal poreikį. Norėdami pamatyti visas galimas instancijų rūšis MinIO, vykdykite:

# NAME stulpelyje matysite reikšmę, kurią reikia nurodyti --instance
stackhero instances-store-list --service-store=minio

4. GitHub Actions

Norėdami pradėti, išsaugokite žemiau pateiktą turinį kaip .github/workflows/ci.yml. Nuo šiol kiekvienas push ir pull request vykdys testus prieš tikrą MinIO instanciją.

name: CI su MinIO

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    env:
      STACKHERO_TOKEN: ${{ secrets.STACKHERO_TOKEN }}
      STACK_NAME: ci-minio-${{ github.run_id }}-${{ github.run_attempt }}
      INSTANCE: "100G"   # Pakeiskite jei reikia (žr. 3 žingsnį)
      REGION: europe
    steps:
      - uses: actions/checkout@v4

      - name: Įdiegti Stackhero CLI ir klientą
        run: |
          curl -fsSL https://www.stackhero.io/install.sh | sh
          apt-get update && apt-get install -y --no-install-recommends jq curl awscli

      - name: Sukurti MinIO paslaugą
        run: |
          set -euo pipefail
          STACK_ID=$(stackhero --format=script stack-create --name="$STACK_NAME")
          echo "STACK_ID=$STACK_ID" >> "$GITHUB_ENV"
          SERVICE_ID=$(stackhero --format=script service-add \
            --stack="$STACK_ID" \
            --service-store="minio" \
            --instance="$INSTANCE" \
            --region="$REGION")
          echo "SERVICE_ID=$SERVICE_ID" >> "$GITHUB_ENV"
          stackhero service-wait-for --service="$SERVICE_ID"

      - name: Vykdyti testus prieš MinIO
        run: |
          set -euo pipefail
          config=$(stackhero service-configuration-get --service="$SERVICE_ID" --format=json)
          host=$(echo "$config" | jq -r '.configuration.domain')
accessKey=$(echo "$config" | jq -r '.configuration.credentials.rootUser')
secretKey=$(echo "$config" | jq -r '.configuration.credentials.rootPassword')
          # List the buckets with the AWS CLI (S3-compatible).
          AWS_ACCESS_KEY_ID="$accessKey" AWS_SECRET_ACCESS_KEY="$secretKey" \
  aws --endpoint-url "https://$host" s3 ls
          echo "✅ MinIO pasiekiamas iš CI."
          # Čia galite paleisti savo testų rinkinį naudodami aukščiau gautus prisijungimo duomenis ...

      - name: Išvalymas (visada, net jei įvyksta klaida)
        if: always()
        run: |
          if [ -n "${SERVICE_ID:-}" ]; then
            stackhero service-delete --service="$SERVICE_ID" --confirm
            stackhero service-wait-for --service="$SERVICE_ID"
          fi
          if [ -n "${STACK_ID:-}" ]; then
            stackhero stack-delete --stack="$STACK_ID" --confirm
          fi

Teardown žingsnis naudoja if: always(), todėl jis bus vykdomas visada, užtikrinant, kad jūsų MinIO instancija bus ištrinta ir jums nebus skaičiuojami mokesčiai už nenaudojamus resursus.

5. GitLab CI

Šią konfigūraciją galite išsaugoti kaip .gitlab-ci.yml. Su šiuo nustatymu kiekvienas pipeline paleidimas sukurs naują tikrą MinIO instanciją jūsų testams.

test:
  image: ubuntu:24.04
  variables:
    STACK_NAME: "ci-minio-$CI_PIPELINE_ID-$CI_JOB_ID"
    INSTANCE: "100G"   # Pakeiskite jei reikia (žr. 3 žingsnį)
    REGION: "europe"
    SERVICE_STORE: "minio"
  # STACKHERO_TOKEN gaunamas iš CI/CD kintamojo, kurį sukūrėte 1 žingsnyje.
  script:
    - set -euo pipefail
    - curl -fsSL https://www.stackhero.io/install.sh | sh
    - apt-get update && apt-get install -y --no-install-recommends jq curl awscli
    - STACK_ID=$(stackhero --format=script stack-create --name="$STACK_NAME")
    - echo "STACK_ID=$STACK_ID" >> deploy.env
    - SERVICE_ID=$(stackhero --format=script service-add --stack="$STACK_ID" --service-store="$SERVICE_STORE" --instance="$INSTANCE" --region="$REGION")
    - echo "SERVICE_ID=$SERVICE_ID" >> deploy.env
    - stackhero service-wait-for --service="$SERVICE_ID"
    - config=$(stackhero service-configuration-get --service="$SERVICE_ID" --format=json)
    - host=$(echo "$config" | jq -r '.configuration.domain')
accessKey=$(echo "$config" | jq -r '.configuration.credentials.rootUser')
secretKey=$(echo "$config" | jq -r '.configuration.credentials.rootPassword')
    # List the buckets with the AWS CLI (S3-compatible).
    - AWS_ACCESS_KEY_ID="$accessKey" AWS_SECRET_ACCESS_KEY="$secretKey" \
  aws --endpoint-url "https://$host" s3 ls
    - echo "✅ MinIO pasiekiamas iš CI."
    # Čia galite paleisti savo testų rinkinį naudodami aukščiau gautus prisijungimo duomenis ...
  after_script:
    - test -f deploy.env && . ./deploy.env || true
    - >
      if [ -n "${SERVICE_ID:-}" ]; then
        stackhero service-delete --service="$SERVICE_ID" --confirm
        stackhero service-wait-for --service="$SERVICE_ID"
      fi
    - >
      if [ -n "${STACK_ID:-}" ]; then
        stackhero stack-delete --stack="$STACK_ID" --confirm
      fi

GitLab aplinkoje išvalymas vykdomas after_script sekcijoje. Ši dalis visada bus vykdoma, net jei job'as nepavyks, todėl jūsų MinIO resursai bus pašalinti ir jums nebus skaičiuojami mokesčiai už nenaudojamus resursus.

GitLab aplinkoje after_script vykdomas naujoje shell sesijoje. Todėl scenarijus job'o metu įrašo paslaugos ir stack ID į deploy.env ir prieš išvalymą juos įkelia iš naujo. Taip užtikrinama, kad net jei job'as nutrūktų, jūsų resursai vis tiek bus išvalyti.

Tai visas CI gyvavimo ciklas su MinIO: sukurkite stack, pridėkite paslaugą, palaukite, gaukite prisijungimo duomenis, atlikite smoke testą ir visada išvalykite. Kiekvienas pipeline paleidimas gauna realią, izoliuotą paslaugą, o pabaigus niekas nelieka veikti. Daugiau informacijos apie galimas komandas ir neinteraktyvų STACKHERO_TOKEN autentifikavimą rasite pilnoje CLI dokumentacijoje.