# Actions Runner Controller o un servizio di runner gestito: cosa scegliere per un team piccolo?

> Actions Runner Controller (ARC) è software gratuito che gestisci sul tuo cluster Kubernetes: due chart Helm, un'immagine del runner che costruisci tu e una reinstallazione a ogni aggiornamento. Un team piccolo ha gli stessi minuti GitHub gratuiti con un runner gestito. Skipbox lo è, a un prezzo fisso di $39 al mese con minuti illimitati: cambi una riga runs-on.

Per un team piccolo, un servizio di runner gestito. Actions Runner Controller (ARC) è un operator Kubernetes: gestisci un cluster, installi due chart Helm, costruisci un'immagine del runner e reinstalli tutto a ogni aggiornamento. GitHub consiglia ARC "for organizations with Kubernetes infrastructure and teams that have Kubernetes expertise".

Skipbox ti dà quello per cui esiste ARC, runner self-hosted i cui minuti GitHub non fattura, senza niente da gestire. I tuoi job girano sulla macchina del tuo account a un prezzo fisso di $39 al mese con minuti illimitati. Cambi una riga `runs-on`.

- ARC: un cluster Kubernetes, due chart Helm, una tua immagine del runner, e una disinstallazione e reinstallazione a ogni aggiornamento
- Skipbox: installi una GitHub App, cambi `runs-on`, e la macchina, l'immagine e gli aggiornamenti li fa Skipbox
- 20.000 minuti al mese su 4 vCPU: $222 su GitHub, $39 su Skipbox

**GitHub Actions a prezzo fisso, minuti illimitati** Skipbox esegue i tuoi job di GitHub Actions su una macchina dedicata tutta tua: $39 al mese, per quanti minuti tu esegua. I layer Docker e le cache delle dipendenze restano tra un job e l'altro, così il job successivo parte subito.

Un runner da 4 vCPU, 20.000 minuti al mese: GitHub $222 → Skipbox $39. Risparmi $183 ogni mese.

Per passare basta una riga: `runs-on: skipbox`.

[Inizia la prova gratuita di 7 giorni](https://app.skipbox.dev/sign-in?ref=g-actions-runner-controller-vs-managed-runners-it)

## Cosa gestisci quando gestisci ARC

Dalla [documentazione di ARC](https://docs.github.com/en/actions/concepts/runners/actions-runner-controller) di GitHub:

| Pezzo | Cosa richiede |
|---|---|
| Un cluster Kubernetes | Il primo prerequisito di ARC, con Helm 3. GitHub consiglia di eseguire i carichi di produzione in isolamento, perché "using a shared Kubernetes cluster for production workloads could pose a security risk" |
| Il controller | Il chart Helm `gha-runner-scale-set-controller`: il pod del controller manager, i suoi ruoli e le custom resource definition di ARC |
| Un runner scale set | Il chart Helm `gha-runner-scale-set`, una volta per ogni tipo di runner: un pod listener che aspetta i job, e un pod runner creato per ogni job |
| Autenticazione | Una GitHub App o un personal access token (classic), salvato come secret di Kubernetes |
| L'immagine del runner | L'immagine di GitHub contiene "the least amount of packages necessary". Per tutto il resto, costruisci e pubblichi la tua |
| Una modalità container | I job che usano container richiedono `dind` (un container Docker-in-Docker privilegiato in ogni pod runner) o `kubernetes` (volumi persistenti o lifecycle hook, e per impostazione predefinita un job senza `container:` fallisce) |
| Limiti di scala | `minRunners` e `maxRunners` per ogni scale set. ARC non ha una pianificazione per cambiarli: lo fa un tuo cron job |
| Log e metriche | GitHub consiglia di raccogliere e conservare i log di controller, listener e runner prima della produzione; le metriche arrivano in formato Prometheus |

Ogni pod runner viene eliminato quando il suo job finisce, quindi le immagini che ha scaricato e i pacchetti che ha installato se ne vanno con lui. Conservarli tra un job e l'altro è uno storage che progetti e prepari tu.

## Quanto costa in lavoro

ARC è software gratuito, e GitHub non fattura niente per i minuti dei runner self-hosted. Il costo sono i nodi del cluster ogni mese, e queste ore:

- **Gli aggiornamenti sono reinstallazioni.** Helm non può aggiornare le custom resource definition di ARC. I [passaggi di aggiornamento](https://docs.github.com/en/actions/how-tos/manage-runners/use-actions-runner-controller/deploy-runner-scale-sets#upgrading-arc) di GitHub: disinstallare ogni runner scale set, aspettare la pulizia, disinstallare ARC, rimuovere le CRD se sono cambiate, installare di nuovo. Senza un secondo cluster, mentre lo fai nessun runner prende job.
- **Il runner invecchia.** GitHub smette di assegnare job a un runner rimasto indietro di più di 63 giorni rispetto a una nuova versione. Con una tua immagine, ricostruirla in tempo è compito tuo.
- **Il debug del cluster tocca a te.** Il [perimetro del supporto di GitHub per ARC](https://docs.github.com/en/actions/concepts/runners/support-for-arc) esclude configurazione e rete di Kubernetes, la costruzione di immagini con Docker-in-Docker, storage e volumi persistenti, policy del cluster e cache delle immagini. Consiglia "staff with expert-level knowledge of container orchestration".
- **Kubernetes stesso.** Aggiornamenti dei nodi, scalabilità automatica dei nodi sotto i runner, e la fattura dei nodi fermi tra un push e l'altro.

Un team piccolo non ha un platform engineer da dedicare a questo. Le ore escono dal lavoro sul prodotto.

## Quanto costano i runner di GitHub se resti

I team guardano ARC per la fattura al minuto. Eccola contro un piano Skipbox:

| Minuti al mese (4 vCPU) | GitHub | Skipbox S | Risparmi ogni mese |
|---|---|---|---|
| 10.000 | $102 | $39 | **$63** |
| 20.000 | $222 | $39 | **$183** |
| 30.000 | $342 | $39 | **$303** |
| Sempre acceso | $500,40 | $39 | **$461,40** |

Le cifre di GitHub sono la fattura su GitHub Team dopo il calcolo incluso. Calcola il prezzo dei tuoi minuti nel [calcolatore della home](https://skipbox.dev/?ref=g-actions-runner-controller-vs-managed-runners-it#cost); non serve accedere.

## Skipbox: i runner, senza il cluster

| | ARC | Skipbox |
|---|---|---|
| Per iniziare | Un cluster, Helm, due chart, un secret, un'immagine | Installi una GitHub App, cambi `runs-on` |
| Fattura di GitHub per i minuti | Nessuna | Nessuna: i runner di Skipbox sono runner self-hosted |
| Costo mensile | I nodi del cluster, per dimensione e ore | $39, $79 o $149, fisso |
| Docker nei job | Docker-in-Docker privilegiato, o modalità Kubernetes | Docker gira nella VM, come su `ubuntu-latest` |
| Cache tra un job e l'altro | Se ne vanno con il pod, a meno che non costruisci uno storage per loro | Restano sul disco della tua macchina |
| Aggiornamenti | Disinstalli e reinstalli | Li fa Skipbox |
| Quando un runner si rompe | Leggi i log del controller e del listener | Controllato dopo ogni job; una macchina che non passa il controllo viene ricostruita in automatico |

- **Un prezzo fisso.** 4 vCPU e 16 GB per $39 al mese, 8 vCPU per $79, 16 vCPU per $149. Minuti illimitati, nessun costo a consumo. Aggiungi piani per eseguire più job insieme; i job oltre le tue macchine aspettano il loro turno.
- **Una macchina tua, già pronta.** Immagini, layer e cache di build di Docker, cache dei pacchetti e tool cache restano tra un job e l'altro: almeno 7× la cache che GitHub dà a un repository. Un pod runner che parte vuoto scarica di nuovo tutto.
- **Un runner per ogni job.** Skipbox registra un runner just-in-time per un job quando il job entra in coda, e lo rimuove dopo. Nessun listener, nessuno scale set, nessun `maxRunners`.
- **Sempre aggiornato.** Il runner, Ubuntu 24.04, Docker, Node 22 e Python 3.12 li aggiorna Skipbox.

## Basta una riga

```yaml
jobs:
  build:
    runs-on: skipbox # was ubuntu-latest, or your scale set's name
    steps:
      - uses: actions/checkout@v4
      - run: npm ci && npm test
```

1. Accedi a Skipbox con GitHub.
2. Installa la GitHub App di Skipbox e scegli i tuoi repository.
3. Cambia `runs-on` e fai push.

I job Linux girano senza modifiche, sui repository pubblici e privati.

## Sicurezza

- La macchina è solo del tuo account; nessun job di altre aziende gira su di essa.
- Dopo ogni job vengono cancellati le credenziali, i processi e i container del runner e i file di credenziali come `~/.npmrc`. Dal 13 novembre 2026 il tuo checkout e il suo output di build (il `target/` di Cargo) restano sulla tua macchina per i job successivi; “VM nuova per ogni job” dà a ogni job una macchina nuova.
- Il codice di chi non ha accesso in scrittura (come le pull request dai fork) gira su una VM nuova, che poi viene eliminata. [Come vengono separati i job](https://docs.skipbox.dev/it/isolation).

## Provalo prima di costruire un cluster

La prova non chiede la carta e dura 7 giorni o 3000 minuti di job. Sposta un job su `runs-on: skipbox` oggi, prima di costruirgli un cluster.

## Domande frequenti

### Actions Runner Controller o un servizio di runner gestito: cosa scegliere per un team piccolo?

Un servizio di runner gestito. Actions Runner Controller (ARC) è un operator Kubernetes: gestisci tu il cluster, installi i suoi due chart Helm, costruisci l'immagine del runner e la reinstalli a ogni aggiornamento. GitHub lo consiglia alle organizzazioni con un'infrastruttura Kubernetes e ai team con competenze Kubernetes. Skipbox dà a un team piccolo gli stessi minuti self-hosted gratuiti senza niente da gestire: un prezzo fisso di $39 al mese per una macchina a 4 vCPU, minuti illimitati, una riga runs-on.

### Actions Runner Controller è difficile da gestire per un team piccolo?

È una piattaforma Kubernetes da tenere in piedi. Ti servono un cluster, Helm, una GitHub App o un token salvato come secret di Kubernetes, una modalità container per i job che usano Docker, una tua immagine del runner con i tool che i tuoi job si aspettano, e la raccolta dei log di controller, listener e runner. La documentazione di GitHub consiglia personale con conoscenze esperte di orchestrazione dei container. Su Skipbox niente di tutto questo esiste: installi una GitHub App e cambi runs-on.

### Quanto costa Actions Runner Controller?

ARC in sé è gratuito, e GitHub non fattura niente per i minuti dei runner self-hosted. Paghi ogni mese il cluster Kubernetes e i suoi nodi, e le ore spese a installarlo, aggiornarlo e farne il debug. Skipbox mette la macchina e il lavoro in un unico prezzo fisso: $39, $79 o $149 al mese per 4, 8 o 16 vCPU, con minuti illimitati.

### Come si aggiorna Actions Runner Controller?

Reinstallandolo. Helm non può aggiornare le custom resource definition di ARC, quindi i passaggi di GitHub sono: disinstallare ogni runner scale set, aspettare la pulizia, disinstallare ARC, rimuovere le sue CRD se sono cambiate e installare di nuovo. Anche il runner dentro la tua immagine deve restare aggiornato: GitHub smette di assegnare job a un runner rimasto indietro di più di 63 giorni rispetto a una nuova versione. Su Skipbox il runner e l'immagine vengono aggiornati per te.

### Serve Kubernetes per scalare in automatico i runner GitHub Actions?

No. ARC è la risposta Kubernetes di GitHub, e la documentazione di GitHub descrive anche come costruire un tuo autoscaler dal client degli scale set o dai webhook. Un runner gestito non ha bisogno di nessuno dei due. Skipbox registra un runner per ogni job quando entra in coda; i tuoi piani stabiliscono quanti job girano insieme, e gli altri aspettano il loro turno.

### Le build Docker funzionano senza Docker-in-Docker su Skipbox?

Sì. Ogni macchina Skipbox è una VM con Docker installato, quindi docker build, docker run, i service container e i container job funzionano come su ubuntu-latest. Su ARC devi prima scegliere una modalità container: Docker-in-Docker, che esegue un container privilegiato, o la modalità Kubernetes, in cui per impostazione predefinita un job senza container fallisce.

Aggiornata il giorno 2026-11-14 · https://skipbox.dev/it/guides/actions-runner-controller-vs-managed-runners
