Skip to main content
Gå til innhold

LLM-tjenester via AWS Bedrock

AWS Bedrock gir tilgang til store språkmodeller (LLM) som Claude fra Anthropic. Denne guiden viser hvordan du tar i bruk LLM-tjenester på din Platon AWS-konto, både for lokal utvikling og for produksjonskjøring i Kubernetes.

Forutsetninger​

Før du starter må du ha:

  1. AWS-konto fra Platon

  2. Grunnleggende kunnskap

    • Kjennskap til AWS basics (IAM, credentials)
    • Erfaring med Kubernetes (for deployment til PaaS)
    • Node.js installert lokalt (for utviklingsverktøy)

  3. Verktøy installert

    • AWS CLI konfigurert
    • kubectl for Kubernetes-operasjoner
    • jq for JSON-parsing: brew install jq (macOS)

Oversikt​

Det finnes tre måter å autentisere mot AWS Bedrock:

  1. AWS SSO - For lokal utvikling med personlige credentials
  2. API-token (pre-signed URL) - For midlertidig tilgang, testing, eller Claude Code
  3. IRSA (IAM Roles for Service Accounts) - For produksjon i Kubernetes

Kom i gang med eksempelprosjektet​

Den enkleste måten å komme i gang med AWS Bedrock er å bruke Platons eksempelprosjekt. Dette prosjektet inneholder alle verktøy og konfigurasjon du trenger.

Klon eksempelprosjektet​

git clone https://gitlab.sikt.no/platon/aws-ai.git
cd aws-ai
npm install
info

Prosjektet er tilgjengelig på GitLab: platon/aws-ai

Se prosjektets README for fullstendig dokumentasjon og alle detaljer.

Lokal utvikling​

Metode 1: AWS SSO (anbefalt for utvikling)​

AWS SSO gir deg midlertidige credentials som varer i noen timer. Dette er den enkleste måten å teste Bedrock API lokalt.

1. Logg inn med SSO​

aws sso login

Dette åpner en nettleser hvor du godkjenner innloggingen mot din Platon AWS-konto.

2. Liste tilgjengelige modeller​

Prosjektet har et praktisk script for å liste modeller:

npm run models
# Eller filtrer kun Claude-modeller:
npm run models -- claude

3. Test API med SSO credentials​

npm run inference:sso

Dette kaller Bedrock API direkte med dine SSO credentials.

Cross-Region Inference

Claude-modeller med eu.-prefiks bruker cross-region inference. Dette gir høyere kapasitet ved å automatisk spre forespørsler over flere EU-regioner (Stockholm, Irland, Paris, Frankfurt, etc.).

Metode 2: API-token (pre-signed URL)​

For situasjoner hvor SSO ikke er tilgjengelig, eller du vil dele tilgang midlertidig, kan du generere et token som varer i opptil 12 timer.

Generer token​

npm run token

Dette genererer en pre-signed URL som lagres i token.json. Tokenet caches automatisk - scriptet sjekker om eksisterende token fortsatt er gyldig før det genererer et nytt.

Token-variasjoner:

npm run token:1h      # Token gyldig i 1 time
npm run token:6h      # Token gyldig i 6 timer
npm run token:force   # Tving generering av nytt token

Test API med token​

npm run inference

Dette bruker tokenet fra token.json til å kalle Bedrock API.

Sikkerhet
  • Tokens er sensitive og gir full tilgang til Bedrock API
  • token.json er git-ignored - commit aldri tokens til Git
  • Del kun tokens gjennom sikre kanaler
  • Slett tokens når de ikke lenger trengs
  • Bruk kortest mulig varighet for økt sikkerhet

Bruk Claude Code med AWS Bedrock​

De fleste utviklere i Sikt har Claude Code tilgang via eget abonnement, men det kan være aktuelt å bruke AWS Bedrock i stedet for:

  • Testing: Teste ut Claude i en kort periode uten å opprette egen konto
  • Autonome agents: Kjøre Claude Code autonomt i Kubernetes eller GitLab pipelines
  • Team-deling: Dele Claude-tilgang mellom teammedlemmer via AWS

Oppsett for lokal bruk​

1. Generer token​

Først må du ha et gyldig Bedrock-token:

npm run token

2. Konfigurer miljøvariabler​

Kjør setup-scriptet som eksporterer nødvendige miljøvariabler:

source setup-claude-bedrock.sh

Dette setter:

  • CLAUDE_CODE_USE_BEDROCK=1 - Aktiverer Bedrock-modus
  • AWS_REGION=eu-west-1 - AWS-region
  • AWS_BEARER_TOKEN_BEDROCK=<token> - Bedrock-token
  • ANTHROPIC_MODEL=<model-id> - Claude-modell å bruke

3. Start Claude Code​

claude

Claude Code vil nå bruke AWS Bedrock i stedet for standard Anthropic API. Alt fungerer som vanlig, men alle forespørsler går via din AWS-konto.

Token-varighet

Tokens varer i opptil 12 timer. Setup-scriptet sjekker automatisk om tokenet er gyldig og viser gjenværende tid. Hvis tokenet utløper, generer et nytt med npm run token.

Bruk i CI/CD pipelines​

For å kjøre Claude Code autonomt i GitLab CI eller Kubernetes, kan du:

  1. Generere et token med ønsket varighet
  2. Lagre tokenet som CI/CD-variabel eller Kubernetes secret
  3. Sette miljøvariablene i jobben/poden
  4. Kjøre Claude Code-kommandoer

Se eksempelprosjektet for detaljer om hvordan dette settes opp.

Kubernetes deployment​

For produksjonskjøring av applikasjoner som bruker Bedrock API i Kubernetes, bruker vi IRSA (IAM Roles for Service Accounts). Dette er den sikreste metoden fordi ingen credentials lagres i poden.

Hvordan IRSA fungerer​

IRSA lar Kubernetes pods få AWS-tilgang uten å lagre credentials:

  1. Pod starter med miljøvariabler som peker til IAM-rolle og service account token
  2. AWS SDK leser automatisk service account token fra poden
  3. AWS STS validerer tokenet mot Kubernetes OIDC provider
  4. Midlertidige credentials utstedes og fornyes automatisk av SDK
  5. Bedrock API kalles med disse credentials

Overordnet fremgangsmåte​

1. Opprett IAM-rolle med CloudFormation​

Eksempelprosjektet inneholder en ferdig CloudFormation-template som oppretter:

  • IAM-rolle med tilgang til Bedrock API
  • Trust policy som tillater Kubernetes pods å bruke rollen via OIDC
  • Permissions policy som gir tilgang til Claude-modeller i alle EU-regioner

Tilpass parameterfilen cloudformation/parameters.json med ditt namespace:

[
  {
    "ParameterKey": "Namespace",
    "ParameterValue": "ditt-namespace"
  },
  {
    "ParameterKey": "BedrockRegion",
    "ParameterValue": "eu-west-1"
  }
]

Deploy med det inkluderte scriptet:

./scripts/deploy-iam-role.sh

Dette oppretter IAM-rollen og lagrer Role ARN til .role-arn filen.

Platon OIDC Provider

Platon PaaS har allerede konfigurert OIDC provider for Kubernetes:

  • Provider ID: 38B1D1609274C2E9AB111FAB92F8B185
  • Region: eu-north-1

Dette er forhåndskonfigurert i CloudFormation-templaten.

Hvorfor alle EU-regioner?

IAM-policyen må tillate alle EU-regioner fordi cross-region inference automatisk kan route forespørsler til hvilken som helst EU-region basert på kapasitet. IAM-sjekken skjer mot destination-regionen, ikke source-regionen.

2. Konfigurer Kubernetes deployment​

Oppdater din deployment.yaml med tre kritiske miljøvariabler:

env:
  - name: AWS_REGION
    value: eu-west-1
  - name: AWS_ROLE_ARN
    value: arn:aws:iam::123456789012:role/bedrock-claude-access
  - name: AWS_WEB_IDENTITY_TOKEN_FILE
    value: /var/run/secrets/kubernetes.io/serviceaccount/token

Viktige punkter:

  • AWS_REGION: Regionen hvor du kaller API (source region)
  • AWS_ROLE_ARN: Output fra CloudFormation (finn i .role-arn fil)
  • AWS_WEB_IDENTITY_TOKEN_FILE: Standard path - endre ikke denne
Automatisk credential-håndtering

Når AWS SDK ser disse miljøvariablene, håndterer den automatisk hele credential-flyten:

  1. Leser Kubernetes service account token
  2. Kaller AWS STS AssumeRoleWithWebIdentity
  3. Mottar midlertidige credentials (gyldige i 15-60 min)
  4. Fornyer credentials automatisk før utløp

Du trenger ikke skrive noe kode for dette - AWS SDK gjør alt!

3. Deploy til Kubernetes​

kubectl apply -f deployment.yaml

4. Verifiser deployment​

Sjekk at poden startet riktig:

kubectl logs -n ditt-namespace -l app=din-app --tail=50

Forventet output:

🚀 Bedrock client configuration:
   Region: eu-west-1
   Model ID: eu.anthropic.claude-sonnet-4-5-20250929-v1:0
🔐 AWS_ROLE_ARN: Set
✅ Client initialized
Server running on port 3000

Se eksempelprosjektet for fullstendig dokumentasjon av Kubernetes-deployment med IRSA.

Viktige konsepter å forstå​

To forskjellige IAM-identiteter​

Når du jobber med AWS Bedrock er det to forskjellige IAM-identiteter involvert:

Din utvikler-rolle (lokal oppsett)​

  • Formål: Sette opp infrastruktur (CloudFormation, IAM-roller)
  • Brukes av: Deg, via aws sso login
  • Eksempel: assumed-role/AdministratorAccess/andreas@sikt.no

App-rollen (IRSA i Kubernetes)​

  • Formål: Kalles av applikasjonen for Bedrock API-tilgang
  • Brukes av: Kubernetes-poden via Web Identity Federation
  • Eksempel: role/bedrock-claude-access

Din utvikler-rolle brukes kun for å sette opp infrastrukturen. App-rollen er den som faktisk brukes av applikasjonen i produksjon. Dette følger prinsippet om least privilege - applikasjonen får kun tilgang til det den trenger.

Hvorfor IRSA er sikkert​

IRSA (IAM Roles for Service Accounts) er mye sikrere enn tradisjonelle metoder:

Tradisjonell tilnærming (unngå dette):

  • ❌ Hardkodede AWS access keys i miljøvariabler
  • ❌ Keys må roteres manuelt
  • ❌ Lang levetid på credentials
  • ❌ Risiko for lekkasje via logs eller minne-dumps

IRSA-tilnærming (anbefalt):

  • ✅ Ingen hardkodede keys - kun midlertidige credentials
  • ✅ Automatisk fornyelse før utløp
  • ✅ Kort levetid (15-60 minutter)
  • ✅ Credentials lagres aldri i poden

Cross-Region Inference​

Claude-modeller med eu.-prefiks bruker cross-region inference:

Hva det betyr:

  • Du kaller API i eu-west-1 (Irland)
  • AWS kan prosessere forespørselen i eu-north-1 (Stockholm), eu-west-3 (Paris), eller andre EU-regioner
  • Routing skjer automatisk basert på kapasitet

Fordeler:

  • ✅ Høyere throughput (opptil dobbel kapasitet)
  • ✅ Bedre tilgjengelighet ved høy trafikk
  • ✅ Automatisk lastbalansering

Konsekvens for IAM:

  • IAM-policyen må tillate alle EU-regioner
  • Ikke bare regionen du kaller API fra

Kostnader​

AWS Bedrock fakturerer per token (ikke per API-kall):

  • Claude Sonnet: Ca. $3 per million input tokens, $15 per million output tokens
  • Claude Haiku: Rimeligere alternativ for enkle oppgaver

Prisene varierer mellom modeller og regioner. Se AWS Bedrock pricing for oppdaterte priser.

Kostnadsovervåking:

  • Alle kostnader vises i AWS-kontoen din
  • Sett opp AWS Budgets for varsler ved uventet forbruk
  • Kostnadene belastes teamets AWS-konto via Platon
tip

For testing og utvikling starter du gjerne med Claude Haiku som er rimeligere. Bytt til Claude Sonnet når du trenger bedre kvalitet i produksjon.

Vanlige problemer​

"AccessDeniedException" ved API-kall​

Symptom:

User is not authorized to perform: bedrock:InvokeModel on resource:
arn:aws:bedrock:eu-north-1::foundation-model/anthropic.claude-*

Vanlige årsaker:

  1. IAM-policy mangler regioner (vanligste problem)

    • Feil: Policy tillater kun eu-west-1, men cross-region inference routet til eu-north-1
    • Løsning: IAM-policy må inkludere alle EU-regioner (se CloudFormation-template)

  2. IRSA ikke konfigurert riktig (Kubernetes)

    • Sjekk at AWS_ROLE_ARN er satt: kubectl exec POD-NAME -- env | grep AWS
    • Verifiser at namespace matcher IAM trust policy
    • Se pod-logger for credential-feil

  3. Utløpte credentials (lokal utvikling)

    • SSO: Kjør aws sso login på nytt
    • Token: Generer nytt med npm run token

"Model not found" eller "Validation Exception"​

Symptom:

ResourceNotFoundException: Could not resolve foundation model

eller

ValidationException: Invocation of model ID with on-demand throughput isn't supported

Løsning:

  • Sjekk at modell-ID har riktig prefiks: eu.anthropic.claude-* for EU
  • Liste tilgjengelige modeller: npm run models -- claude
  • Verifiser at du har aktivert model access i AWS Bedrock Console

Token utløper for raskt​

For lokal utvikling:

  • Tokens varer i opptil 12 timer - generer med lengre varighet: npm run token (standard 12t)
  • Vurder å bruke SSO i stedet: npm run inference:sso

For produksjon:

  • Bruk alltid IRSA i Kubernetes - credentials fornyes automatisk

Neste steg​

Støtte​

  • Spørsmål om Platon AWS: Platon support
  • Tekniske problemer: GitLab issues i platon/aws-ai
  • AWS Bedrock-spesifikke: AWS Support via din AWS-konto