Installera Claude Code och ChatGPT Codex på en Linux-server: steg för steg

Den här guiden tar dig från en nyinstallerad Debian- eller Ubuntu-server till en fungerande AI-agent som analyserar loggar, kontrollerar konfigurationer och utför underhållsuppgifter. Vi sätter upp Claude Code (Anthropic) och Codex CLI (OpenAI, kommandoradsverktyget bakom ChatGPT), båda under en egen användare med begränsade rättigheter, och visar Gemini CLI (Google) som ett tredje alternativ. Alla kommandon har testats på en KVM-rootserver från KernelHost med Debian 13 och Ubuntu 24.04. Vad en AI-hanterad server är i grunden och vilka arkitekturer som finns beskrivs i artikeln AI-hanterad server: koppla AI-agenter säkert.

Läget i september 2026. Verktygen utvecklas snabbt; kontrollera flaggorna med claude --help, codex --help respektive gemini --help om du är osäker.

Förutsättningar

• En rootserver med Debian 12 eller 13 alternativt Ubuntu 22.04 eller 24.04 och rootåtkomst via SSH. På AlmaLinux och Rocky Linux är stegen desamma, bara paketkommandona heter dnf i stället för apt.
• Grundläggande härdning på plats: SSH-inloggning med nyckel, brandvägg, automatiska säkerhetsuppdateringar. Checklistan för nya rootservrar täcker det.
• Ett konto hos Anthropic (Claude Pro, Max eller Team) eller en API-nyckel, ett ChatGPT-konto (Plus, Pro eller Team) eller en OpenAI-API-nyckel. Du behöver bara ett av dem om du bara vill sätta upp ett verktyg.
• Utgående HTTPS till api.anthropic.com och api.openai.com. På KernelHost-servrar är det öppet från start, en restriktiv egen brandvägg måste tillåta det.

Vilken server räcker för en AI-agent?

En AI-agent behöver ingen särskild hårdvara och ingen GPU på servern, eftersom språkmodellen körs hos leverantören. På servern körs bara kommandoradsverktyget och Node.js, som tillsammans oftast använder några hundra megabyte arbetsminne under en session. För en server där inte mycket annat körs räcker 2 vCPU och 4 GB RAM. Om servern dessutom kör webbplatser, databaser eller spelservrar bör du räkna med ungefär 1 GB arbetsminne i reserv för agenten. En KVM-rootserver från KernelHost är driftklar på ungefär 30 sekunder, debiteras PrePaid utan bindningstid och lämpar sig därmed även som testsystem där du först provar agenten.

Steg 1: skapa en egen användare och begränsa sudo

Agenten körs aldrig som root. Den får ett eget konto och via en sudo-tillåtelselista exakt de kommandon den behöver. Börja med några få läsande kommandon och utöka listan när en uppgift verkligen kräver det.

sudo adduser --disabled-password --gecos "KI-Agent" aiagent
sudo tee /etc/sudoers.d/aiagent >/dev/null <<'EOF'
aiagent ALL=(root) NOPASSWD: /usr/bin/journalctl *, /usr/bin/systemctl status *, /usr/bin/systemctl restart nginx, /usr/bin/apt-get update, /usr/bin/apt-get upgrade -y, /usr/bin/tail *, /usr/bin/df *, /usr/bin/ss *
EOF
sudo chmod 440 /etc/sudoers.d/aiagent
sudo visudo -cf /etc/sudoers.d/aiagent

Den sista raden kontrollerar syntaxen. Ett fel i en sudoers-fil kan spärra sudo för alla, därför hör kontrollen alltid till. --disabled-password ser till att ingen kan logga in som aiagent med lösenord; du byter senare till kontot med sudo -iu aiagent. Hur sudo-användare fungerar i grunden förklaras i artikeln Skapa en sudo-användare i Linux.

Riktade skrivrättigheter i stället för en editor via sudo

Om agenten ska ändra filer i /etc ska du inte ge den nano via sudo (då skulle den kunna redigera vilken fil som helst, även /etc/sudoers), utan arbeta med en grupp och riktade skrivrättigheter, till exempel setfacl -m u:aiagent:rw /etc/nginx/sites-available/meine-seite.conf. Till att börja med räcker det helt att agenten föreslår ändringar och att du själv för in dem.

Detsamma gäller kommandon med jokertecken i tillåtelselistan. /usr/bin/tail * låter agenten läsa varje fil som root har åtkomst till, även filer med inloggningsuppgifter. Den som inte vill det skriver ut de tillåtna sökvägarna, till exempel /usr/bin/tail -n 200 /var/log/nginx/error.log.

Steg 2: installera Node.js 22

Båda verktygen körs på Node.js. Claude Code kräver minst version 18, Codex CLI minst 22, därför installerar vi 22 LTS. Paketkällorna i Debian 12 levererar en för gammal version; NodeSource levererar den aktuella:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs
node --version
npm --version

Alternativ utan rooträttigheter: nvm

Den som inte vill köra skript från internet med rooträttigheter använder nvm i agentanvändarens hemkatalog; då går det helt utan rooträttigheter. Installationskommandot för nvm hämtar du från projektets README, därefter räcker tre rader:

nvm install 22
nvm alias default 22
node --version

Detaljer och fler sätt finns i guiden för Node.js på Debian.

Steg 3: installera Claude Code och logga in

Härifrån arbetar vi i agentens konto:

sudo -iu aiagent
curl -fsSL https://claude.ai/install.sh | bash
claude --version

Det nativa installationsprogrammet lägger Claude Code under ~/.local/bin, där programmet sedan uppdaterar sig självt. Alternativt går det via npm med npm install -g @anthropic-ai/claude-code; misslyckas det med EACCES hjälper felsökningsavsnittet längre ned.

Inloggning på en server utan webbläsare

Vid första starten av claude ber verktyget dig att logga in. Med ett Claude-konto öppnar det normalt webbläsaren; på en server utan webbläsare visar det en adress och en kod som du bekräftar på den bärbara datorn eller mobilen. Inloggningen gäller sedan för den här användaren på den här servern tills du loggar ut.

API-nyckel för skript och cronjobb

För skript och cronjobb är en API-nyckel det bättre valet:

echo 'export ANTHROPIC_API_KEY="sk-ant-..."' >> ~/.bashrc
chmod 600 ~/.bashrc
source ~/.bashrc
claude -p "Svara bara med OK" 

Nyckeln ligger därmed bara i agentanvändarens hemkatalog, som andra användare inte kan läsa. Skapa den i Anthropic-konsolen med en månatlig utgiftsgräns, så kan en session som spårar ur inte bli dyr. Själva nyckeln skriver du aldrig in i en uppgift till agenten och aldrig i en fil som den ska visa.

Steg 4: konfigurera Claude Code för servern

Regelfilen CLAUDE.md

Claude Code läser vid start en fil CLAUDE.md i den aktuella katalogen. Där står reglerna som gäller för varje session. Skapa en arbetskatalog med den här filen i agentens hemkatalog:

mkdir -p ~/server && cd ~/server
cat > CLAUDE.md <<'EOF'
# Regler för den här servern
- Detta är en produktionsserver (Debian 13, nginx, PHP-FPM, MariaDB).
- Läsande kommandon (journalctl, systemctl status, tail, df, ss) är alltid tillåtna.
- Förklara kort före varje skrivande kommando vad det ändrar, och vänta på godkännande.
- Paket får aldrig tas bort, filer under /var/lib får aldrig raderas och användare får varken skapas eller tas bort.
- Upprepa aldrig lösenord, nycklar eller kunddata i utdata.
- Lämna en sammanfattning på tre meningar i slutet av varje uppgift.
EOF

Filen växer med tiden. Varje gång agenten gör något på ett annat sätt än du vill, lägger du in korrigeringen som en ny regel. Efter några veckor speglar den arbetssättet på din server ganska exakt.

Tillåtelselistan i settings.json

Till det kommer en tillåtelselista för verktygen, så att Claude Code kör läsande kommandon utan att fråga och ber om godkännande för allt annat. Filen ~/.claude/settings.json gäller för användaren:

mkdir -p ~/.claude
cat > ~/.claude/settings.json <<'EOF'
{
  "permissions": {
    "allow": [
      "Bash(sudo journalctl:*)",
      "Bash(sudo systemctl status:*)",
      "Bash(sudo tail:*)",
      "Bash(df:*)",
      "Bash(free:*)",
      "Bash(ss:*)"
    ],
    "deny": [
      "Bash(rm -rf:*)",
      "Bash(sudo rm:*)",
      "Bash(dd:*)",
      "Bash(mkfs:*)"
    ]
  }
}
EOF

Deny-listan är ett extra skyddsnät, ingen mur: ett kommando kan skrivas på många sätt. Den egentliga gränsen dras av sudo-tillåtelselistan från steg 1, för det som användaren inte får göra får inte heller agenten göra.

Den första uppgiften interaktivt

Nu den första uppgiften, interaktivt:

cd ~/server && claude
> Sammanfatta felen från journalctl under de senaste 24 timmarna och ange de tre vanligaste orsakerna.

Obevakat via cronjobb

Och samma uppgift obevakat, till exempel som ett dagligt cronjobb klockan 7 vars resultat kommer via e-post:

0 7 * * * cd /home/aiagent/server && /home/aiagent/.local/bin/claude -p "Sammanfatta fel och varningar från journalctl under de senaste 24 timmarna. Ange tjänst, tidpunkt och trolig orsak." --allowedTools "Bash(sudo journalctl:*)" 2>&1 | mail -s "Daglig serverrapport" admin@example.com

Flaggan -p startar Claude Code utan interaktiv session, --allowedTools begränsar verktygen till exakt det som körningen behöver. Skrivande åtgärder hör inte hemma i obevakade körningar. Hur cronjobb sätts upp i allmänhet beskrivs i artikeln Skapa ett cronjobb i Linux.

Steg 5: installera Codex CLI (ChatGPT) och logga in

Installation och inloggning

Codex CLI är OpenAI:s verktyg som tar modellerna bakom ChatGPT till kommandoraden. Installationen görs i samma användarkonto:

npm install -g @openai/codex
codex --version

Inloggningen sker med ChatGPT-kontot (Plus, Pro eller Team): starta codex, välj ”Sign in with ChatGPT” och öppna den visade adressen på en enhet med webbläsare. För skript anger du i stället en API-nyckel från OpenAI-plattformen:

echo 'export OPENAI_API_KEY="sk-..."' >> ~/.bashrc
source ~/.bashrc

Sandlåda och godkännandeläge i config.toml

Codex har en egen sandlåda och ett eget godkännandeläge. Båda ställs in i ~/.codex/config.toml; för en produktionsserver är den här kombinationen lämplig:

mkdir -p ~/.codex
cat > ~/.codex/config.toml <<'EOF'
approval_policy = "on-request"
sandbox_mode = "workspace-write"
EOF

workspace-write tillåter skrivning bara i den aktuella arbetskatalogen, on-request låter agenten be om lov för allt utöver det. Nivån danger-full-access upphäver båda och hör inte hemma på ett produktionssystem.

Regler i AGENTS.md

Regler som i CLAUDE.md läser Codex från en fil AGENTS.md i arbetskatalogen; du kan använda samma innehåll:

cp ~/server/CLAUDE.md ~/server/AGENTS.md
cd ~/server && codex "Kontrollera om alla aktiverade systemd-tjänster körs och lista de som har misslyckats med det senaste felmeddelandet."

För obevakade körningar finns codex exec "Aufgabe", motsvarigheten till claude -p.

Steg 6: Gemini CLI som tredje alternativ

Gemini CLI är Googles kommandoradsverktyg och fungerar enligt samma princip. Det körs också på Node.js och installeras i samma användarkonto:

npm install -g @google/gemini-cli
gemini --version

Vid första starten av gemini loggar du in med ett Google-konto; för skript anger du en API-nyckel i miljövariabeln GEMINI_API_KEY. Reglerna läser Gemini CLI från en fil GEMINI.md i arbetskatalogen, och även här kan du återanvända innehållet i CLAUDE.md. Obevakade körningar startar du med gemini -p "Aufgabe". Vilket av de tre verktygen du använder är framför allt en fråga om vilket konto du redan har: arbetssättet på servern är detsamma för alla tre, och du kan köra flera sida vid sida.

Alternativ: agenten körs på din dator och arbetar via SSH

Den som inte vill installera något på servern startar Claude Code eller Codex på den bärbara datorn och låter agenten skicka kommandon via SSH. För det får servern en egen SSH-nyckel för agentanvändaren, och i CLAUDE.md står regeln att alla serverkommandon ska inledas med ssh aiagent@server. Det fungerar bra för sporadiskt underhåll, men längre uppgifter och cronjobb körs bättre direkt på servern. Hur SSH-anslutningen med egen nyckel, host-alias och godkännanden ser ut i detalj, och enligt vilket arbetsflöde agenten sedan driftsätter på produktionssystem, visar erfarenhetsrapporten Koppla AI till servern.

Steg 7: säkra och sätt gränser

• Ögonblicksbild eller backup före varje session där något ska ändras. Backupstrategin för servrar visar hur det sker automatiskt.
• Låt godkännandeläget vara på. --dangerously-skip-permissions i Claude Code och danger-full-access i Codex är avsedda för en engångs-VM.
• Hemligheter utom räckhåll. Agentanvändaren får inte kunna läsa .env-filer, databaslösenord och kunddata. Det den läser går till leverantören.
• Kostnadsgräns för varje API-nyckel, inställd i leverantörens konsol.
• Spårbarhet: installera etckeeper så att varje ändring under /etc hamnar i Git, och spara agentens sammanfattningar.
• Inget ändras för inkommande trafik. Båda verktygen behöver bara utgående HTTPS. Brandvägg, Fail2ban och hostingleverantörens DDoS-skydd förblir oförändrade.

De första uppgifterna: fem lämpliga uppdrag

De bästa första uppgifterna är sådana som innebär mycket läsning och ingen risk. De visar snabbt hur grundligt agenten arbetar och ger nytta direkt:

• Loggrapport: ”Sammanfatta felen och varningarna från de senaste 24 timmarna, grupperade per tjänst, med den troliga orsaken.”
• Kontrollera tjänster: ”Lista alla misslyckade systemd-tjänster med det senaste felmeddelandet och förklara vad som behöver göras för var och en. Ändra ingenting.”
• Diskutrymme: ”Visa vilka kataloger som tar mest plats och föreslå vad som kan rensas utan risk.” Bakgrunden finns i artikeln Full hårddisk i Linux.
• Uppdateringar: ”Vilka paket har väntande säkerhetsuppdateringar, och vilka tjänster måste startas om efteråt?”
• Webbserver: ”Leta efter fel och föråldrade inställningar i nginx-konfigurationen och förklara varje fynd.”

Först när de här analyserna stämmer lönar det sig att ge agenten skrivande uppgifter, och då först på ett testsystem.

Typiska fel och lösningar

Håll verktygen uppdaterade

Claude Code uppdaterar sig självt när det har installerats med det nativa installationsprogrammet. Verktygen som installerats via npm uppdaterar du med ett enda kommando:

npm update -g @openai/codex @google/gemini-cli
codex --version
gemini --version

Nya versioner ändrar ibland flaggor eller standardinställningar. Läs igenom versionsanteckningarna efter en uppdatering innan du låter obevakade körningar fortsätta, och kontrollera om nästa dagliga rapport innehåller något avvikande.

Slutsats

En AI-agent på servern är uppsatt på en timme: användare, sudo-tillåtelselista, Node.js, verktyg, regler. Det egentliga arbetet ligger i gränserna, och de är här medvetet snävt dragna. Utöka dem steg för steg när en uppgift kräver det, aldrig i klump. På en KernelHost-rootserver eller dedikerad server behöver inget aktiveras för det: rootåtkomst, fritt val av distribution och utgående anslutningar är standard.

Hur en agent sedan driftsätter på produktionssystem, med backup, väg tillbaka och godkännanden, beskriver erfarenhetsrapporten Koppla AI till servern.

Kort sammanfattning

• Claude Code, Codex CLI och Gemini CLI körs på varje Linux-server med Node.js 22, någon GPU behövs inte.
• Agenten får en egen användare med sudo-tillåtelselista och körs aldrig som root.
• Reglerna står i CLAUDE.md, AGENTS.md eller GEMINI.md, läsande kommandon hamnar i tillåtelselistan och allt annat kräver godkännande.
• För cronjobb och skript är en API-nyckel med utgiftsgräns den rena lösningen, och obevakade körningar förblir läsande.
• Backup före varje session, hemligheter utom räckhåll, godkännandeläget på.
• På KernelHost-servrar finns rootåtkomst, fritt val av distribution och utgående anslutningar från start.