ms-ai-architect/skills/ms-ai-governance/references/monitoring-observability/cost-monitoring-cost-attribution.md

# Cost Monitoring and Expense Reporting for AI Deployments

**Last updated:** 2026-02
**Status:** GA
**Category:** Monitoring & Observability

---

## Introduksjon

Kostnadskontroll er kritisk for AI-prosjekter der utgifter kan eskalere raskt gjennom tokenforbruk, modelldrifting og compute-ressurser. Effektiv kostnadsmonitorering kombinerer sanntidssporing av forbruk, granulær kostnadsfordeling per forretningsenhet eller applikasjon, og automatiserte varsler som forebygger budsjettoverskridelser før de påvirker prosjektøkonomien.

Azure Cost Management gir innebygd synlighet på abonnements- og ressursgruppe-nivå, men AI-arbeidslaster krever ofte mer sofistikerte løsninger — spesielt for chargeback-modeller, multi-tenant-scenarier eller når man trenger å korrelere kostnader med ytelsesmetrikker. Gateway-basert overvåking (f.eks. via Azure API Management) kan fange opp detaljert bruksdata per klient-IP, modell og token-type, noe som åpner for presise kostnadsallokeringer og prediktiv budsjettering.

Denne guiden dekker både native Azure-verktøy og arkitekturmønstre for avansert kostnadssporing, med fokus på Azure OpenAI, Azure AI Foundry og andre AI-tjenester.

---

## Kjernekomponenter

| Komponent | Formål | Granularitet |
|-----------|--------|--------------|
| **Azure Cost Management** | Sentral kostnadssporing for alle Azure-ressurser | Abonnement, ressursgruppe, ressurs |
| **Cost Analysis** | Visualisering av kostnader over tid med filters og gruppering | Dag, måned, år; gruppering per meter/tag/SKU |
| **Budgets & Alerts** | Automatiserte varsler ved budsjettgrenser | Budsjettgrense (50%, 80%, 100%) med e-postvarsler |
| **Tags & Tag Inheritance** | Kostnadsfordeling per prosjekt/team/miljø | Resource-level tags propagert til forbruksposter |
| **Diagnostic Settings** | Eksport av loggdata til Azure Monitor Logs | Per ressurs (genererer ekstra kostnader) |
| **Gateway Logging** (APIM) | Detaljert tracking av token-forbruk per klient | IP-adresse, modell, prompt/completion tokens, timestamp |
| **Azure Marketplace Meters** | Separat fakturering for 3rd-party modeller (Cohere, Meta) | SaaS-meter per modell-tilbud (input/output tokens) |

### Azure OpenAI-spesifikke meters

| Meter Type | Beskrivelse | Faktureringsmodell |
|------------|-------------|-------------------|
| **Tokens (input/output)** | Per 1000 tokens for chat/completion | Pay-as-you-go eller PTU |
| **Fine-tuning training** | Per token i treningsfilen | Engangsbelastning |
| **Fine-tuning hosting** | Per time per distribuert modell | Kontinuerlig (selv når inaktiv) |
| **Fine-tuning inference** | Per 1000 tokens ved kall til modell | Pay-as-you-go |
| **Image generation** | Fast pris per bilde (f.eks. DALL-E) | Per request |

**Viktig:** Fine-tuned modeller genererer timekostnader selv når de ikke er i bruk. Deployments som er inaktive i 15 dager slettes automatisk (men underliggende modell bevares).

---

## Arkitekturmønstre

### 1. Native Cost Monitoring (Subscription/Resource Group Scope)

**Bruksområde:** Enkle scenarier med én applikasjon per Azure OpenAI-ressurs, eller når man kun trenger aggregert kostnadsoversikt.

**Implementering:**
1. Naviger til Azure Portal → Cost Management + Billing → Cost Analysis
2. Scope til Resource Group eller Subscription
3. Filter på Service Tier: "Azure OpenAI" (OpenAI vises under Cognitive Services)
4. Gruppér på Meter for å se tokenforbruk per modell-serie

**Fordeler:**
- Ingen ekstra infrastruktur kreves
- Innebygd i Azure-portalen
- Fungerer "out of the box" for alle ressurser

**Ulemper:**
- Mangler client-granularitet (IP-adresse maskert til /24)
- Vanskelig å implementere chargeback per team/applikasjon
- Aggregert over alle Azure OpenAI-instanser per region

**Kostnadsindikatorer:**
- Gratis (inkludert i Azure-abonnement)
- Konfidensgrad: **Verified** (Microsoft Learn)

---

### 2. Tag-Based Cost Allocation

**Bruksområde:** Kostnadsfordeling per prosjekt, kostsenter, miljø (dev/prod) eller eier.

**Implementering:**
```bash
# Tagg Azure OpenAI-ressurs
az resource tag --tags Environment=Production Project=ChatbotAI CostCenter=IT-001 \
  --ids /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{openai-name}

# Aktiver tag-inheritance i Cost Management
az feature register --namespace Microsoft.CostManagement --name EnableTagInheritance
```

**Best practices:**
| Tag Key | Formål | Eksempel |
|---------|--------|----------|
| `Project` | Prosjektnavn | `ChatbotAI`, `DocumentAnalysis` |
| `CostCenter` | Økonomisk ansvar | `IT-001`, `R&D-003` |
| `Environment` | Miljø | `Production`, `Development`, `Test` |
| `Owner` | Teknisk ansvarlig | `team-ai@example.com` |

**Fordeler:**
- Automatisk kostnadssplitt uten kodeendringer
- Tag inheritance propagerer tags til child-ressurser
- Integrert med Cost Analysis filters

**Ulemper:**
- Krever disiplinert tagging-strategi
- Tags må vedlikeholdes manuelt (eller via IaC)
- Ikke granulært nok for per-bruker chargeback

**Kostnadsindikatorer:**
- Gratis feature
- Konfidensgrad: **Verified** (Microsoft Learn)

---

### 3. Gateway-Based Cost Attribution (Azure API Management)

**Bruksområde:** Chargeback per applikasjon/team, detaljert token-tracking, korrelering av kostnad med ytelse.

**Arkitektur:**
```
Client A → APIM Gateway → Azure OpenAI (gpt-4o)
Client B ↗               → Azure OpenAI (gpt-35-turbo)
         ↓
    Azure Monitor Logs
    (IP, model, tokens, timestamp)
```

**Implementering (KQL-query for chargeback):**
```kusto
ApiManagementGatewayLogs
| where tolower(OperationId) in ('completions_create','chatcompletions_create')
| extend model = tostring(parse_json(BackendResponseBody)['model'])
| extend prompttokens = parse_json(parse_json(BackendResponseBody)['usage'])['prompt_tokens']
| extend completiontokens = parse_json(parse_json(BackendResponseBody)['usage'])['completion_tokens']
| extend totaltokens = parse_json(parse_json(BackendResponseBody)['usage'])['total_tokens']
| extend client_ip = CallerIpAddress
| summarize
    TotalPromptTokens = sum(todecimal(prompttokens)),
    TotalCompletionTokens = sum(todecimal(completiontokens)),
    TotalCost = sum(todecimal(totaltokens)) * 0.00002  // Eksempel: $0.02 per 1k tokens
    by client_ip, model
| order by TotalCost desc
```

**Fordeler:**
- Fanger full client IP-adresse (ikke maskert)
- Kan legge til custom identifiers (team ID, subscription key)
- Korrelerer tokens med spesifikk modell og timestamp
- Støtter custom dashboards i Azure Monitor Workbooks

**Ulemper:**
- Ekstra latency (typisk 10-50ms)
- APIM-kostnader (Basic tier: ~$140/måned, Standard: ~$700/måned)
- Ekstra kompleksitet i arkitekturen
- Azure Monitor Logs storage costs (ca. $2.50 per GB ingested)

**Kostnadsindikatorer:**
- APIM Basic: ~$140/mnd
- Azure Monitor Logs: ~$2.50/GB ingested + $0.12/GB retention (>31 days)
- Konfidensgrad: **Verified** (Microsoft Learn + Azure Architecture Center)

---

### 4. Multi-Model / Marketplace Cost Tracking

**Bruksområde:** Azure Foundry-prosjekter som bruker både Microsoft-modeller (OpenAI) og 3rd-party modeller (Cohere, Meta).

**Utfordringer:**
- Microsoft-modeller vises som meters under Cognitive Services-ressursen
- 3rd-party modeller vises som SaaS-meters under Resource Group (ikke under Foundry-ressursen)
- Må scope Cost Analysis til Resource Group-nivå for å se alle kostnader

**Implementering:**
1. Naviger til Cost Analysis → Scope til Resource Group
2. Gruppér på **Meter** → filtrer på `Service Name: SaaS`
3. Expand meter details for å se input/output tokens per modell

**Marketplace-meters:**
| Meter Name | Beskrivelse |
|------------|-------------|
| `paygo-inference-input-tokens` | Input tokens (base model) |
| `paygo-inference-output-tokens` | Output tokens (base model) |
| `paygo-finetuned-model-inference-hosting` | Hosting cost per endpoint |
| `paygo-finetuned-model-inference-input-tokens` | Input tokens (fine-tuned) |
| `paygo-finetuned-model-inference-output-tokens` | Output tokens (fine-tuned) |

**Fordeler:**
- Fullstendig kostnadsoversikt på tvers av leverandører
- Separate meters per modell gjør det enkelt å identifisere kostnadsdriver

**Ulemper:**
- Må huske å scope til Resource Group (ikke Foundry-ressurs)
- 3rd-party modeller kan ikke betales med Azure Prepayment
- Forskjellige meters per leverandør (ingen standardisering)

**Kostnadsindikatorer:**
- Ingen ekstra kostnad (native Cost Analysis)
- Konfidensgrad: **Verified** (Microsoft Learn)

---

## Beslutningsveiledning

### Når bruke hvilken strategi?

| Scenario | Anbefalt Løsning | Kostnadsestimering (per mnd) |
|----------|------------------|----------------------------|
| Enkelt prosjekt, én applikasjon, aggregert kostnadsoversikt | Native Cost Analysis | Gratis |
| Flere prosjekter, behov for kostnadsfordeling per team | Tag-Based Allocation | Gratis |
| Multi-tenant SaaS, chargeback per kunde | Gateway (APIM) + Azure Monitor | $140-700 (APIM) + $50-200 (logs) |
| Azure Foundry med Microsoft + 3rd-party modeller | Resource Group Scope + Marketplace Filters | Gratis |
| Behov for real-time kostnadsvarsler (<1 time latency) | Gateway + Event Hub + Stream Analytics | $200-500 |

### Vanlige feil

| Feil | Konsekvens | Løsning |
|------|------------|---------|
| Scope Cost Analysis til Azure OpenAI-ressurs når man bruker Marketplace-modeller | Ser ikke 3rd-party kostnadene | Scope til Resource Group |
| Glemmer å slette inactive fine-tuned deployments | Kontinuerlige timekostnader selv uten bruk | Automatiser cleanup med Azure Automation |
| Bruker kun native logging for chargeback | IP-adresse maskert, mangler team-identifikator | Implementer gateway med custom headers |
| Ikke setter budsjett-alerts | Overskridelser oppdages for sent | Sett alerts ved 50%, 80%, 100% |
| Eksporterer alle logs til Azure Monitor | Høye storage-kostnader | Filtrer ut irrelevante loggkategorier |

### Røde flagg

- **Fine-tuned modeller med 0 requests siste 7 dager:** Vurdér å slette deployment (bevarer modellen)
- **Token-kostnad øker >50% uten tilsvarende økning i brukere:** Sjekk for ineffektive prompts eller loops
- **3rd-party modeller som ikke vises i Cost Analysis:** Kontrollér at Marketplace SaaS-filter er aktivert
- **Chargeback-rapporter som ikke summerer til total cost:** Sannsynligvis mangler 3rd-party eller metadata-kostnader

---

## Integrasjon med Microsoft-stakken

### Azure Monitor + Cost Management

**Native integrasjon:**
- Cost Analysis kan vises direkte i Azure Foundry-portalen (via "View More Details")
- Azure Monitor Workbooks kan kombinere cost data med telemetry (QPS, latency, errors)

**Custom dashboards:**
```kusto
// Korrelere kostnad med ytelse (gjennomsnitts-latency per modell)
let cost_data = ApiManagementGatewayLogs
    | where tolower(OperationId) in ('completions_create','chatcompletions_create')
    | extend model = tostring(parse_json(BackendResponseBody)['model'])
    | extend tokens = parse_json(parse_json(BackendResponseBody)['usage'])['total_tokens']
    | summarize TotalTokens = sum(todecimal(tokens)) by model;
let perf_data = ApiManagementGatewayLogs
    | extend model = tostring(parse_json(BackendResponseBody)['model'])
    | summarize AvgLatency = avg(DurationMs) by model;
cost_data
| join kind=inner perf_data on model
| project model, TotalTokens, AvgLatency, CostPerRequest = TotalTokens * 0.00002 / AvgLatency
```

### Power BI + Cost Data Export

**Implementering:**
1. Sett opp scheduled export i Cost Management (daglig/ukentlig til Storage Account)
2. Koble Power BI til Storage Account via Azure Blob Storage connector
3. Bygg dashboards for ledelse med trender, forecasts, kostnadsfordeling

**Best practice:** Bruk Power BI Premium for å aktivere automatic refresh og deling med stakeholders.

### Azure Automation for Cost Alerts

**Scenario:** Automatisk shutdown av under-utilized ressurser.

```powershell
# Azure Automation Runbook (trigges av Cost Management alert)
param(
    [string]$ResourceGroupName,
    [string]$DeploymentName
)

# Sjekk siste 7 dagers bruk
$metrics = Get-AzMetric -ResourceId "/subscriptions/.../deployments/$DeploymentName" `
    -MetricName "TokensGenerated" -StartTime (Get-Date).AddDays(-7) -EndTime (Get-Date)

if ($metrics.Data.Total -eq 0) {
    Write-Output "Deployment $DeploymentName har 0 requests siste 7 dager. Sletter..."
    Remove-AzCognitiveServicesAccountDeployment -Name $DeploymentName -ResourceGroupName $ResourceGroupName
}
```

---

## Offentlig sektor (Norge)

### Datasuverenitet og kostnadsrapportering

**Krav:** Forvaltningsloven § 17 krever at offentlige virksomheter kan dokumentere kostnader for innsynsbegjæringer og tjenesteutvikling.

**Implementering:**
- Bruk tag `Project` til å skille mellom interne prosjekter og publikumsrettede tjenester
- Eksportér cost data til norsk lagringsområde (Norway East/West)
- Behold cost logs i minimum 5 år (Arkivlova)

### GDPR og kostnadssporing

**Utfordring:** Gateway-logging kan fange opp IP-adresser som er personopplysninger.

**Løsning:**
- Anonymiser IP-adresser i logs (fjern siste oktet eller bruk hashing)
- Lagre logs i Norge med pseudonymisering
- Implementér data retention policies (slett etter 90 dager hvis ikke nødvendig)

**Eksempel (APIM policy for IP-masking):**
```xml
<policies>
    <inbound>
        <set-variable name="client-ip" value="@{
            var ip = context.Request.IpAddress;
            return ip.Substring(0, ip.LastIndexOf('.')) + ".0";
        }" />
    </inbound>
</policies>
```

### Anskaffelser og kostnadsprediksjon

**Krav:** Offentlige anskaffelser krever estimat på totalkostnad (TCO) før valg av leverandør.

**Metode:**
1. Estimér månedlig token-forbruk basert på antall brukere og use case
2. Bruk Azure Pricing Calculator for Pay-as-you-go
3. Sammenlign med PTU (Provisioned Throughput Units) for stabile workloads
4. Inkludér gateway-kostnader (APIM) og storage (Azure Monitor) i TCO

**Eksempel-estimat:**
- 1 million requests/mnd × 1000 tokens/request × $0.02/1k tokens = $20,000/mnd
- APIM Standard tier: $700/mnd
- Azure Monitor Logs (100 GB/mnd): $250/mnd
- **Total TCO:** ~$21,000/mnd

---

## Kostnad og lisensiering

### Prismodell-oversikt (Azure OpenAI)

| Modell-serie | Input (per 1k tokens) | Output (per 1k tokens) | PTU (per 100 units/time) |
|--------------|----------------------|----------------------|------------------------|
| GPT-4o | $0.005 | $0.015 | $36/time |
| GPT-4 Turbo | $0.01 | $0.03 | $72/time |
| GPT-3.5 Turbo | $0.0005 | $0.0015 | $4/time |
| Embedding (ada-002) | $0.0001 | N/A | $1/time |

**PTU vs Pay-as-you-go:**
- **PTU:** Fast månedlig kostnad, garantert throughput (TPM/RPM), egnet for stabile workloads
- **Pay-as-you-go:** Betaler kun for faktisk forbruk, elastisk, egnet for sporadisk bruk

**Break-even point:** PTU blir billigere hvis du konsekvent bruker >80% av reservert kapasitet.

### Optimaliseringstips

| Teknikk | Besparelse | Implementering |
|---------|-----------|----------------|
| **Prompt caching** | 50-90% på repeterte prompts | Bruk Azure OpenAI cache-støtte (beta) |
| **Token-optimalisering** | 20-40% | Fjern unødvendig whitespace, bruk kortere system messages |
| **Model selection** | 50-70% | Bruk GPT-3.5 Turbo for enkle oppgaver i stedet for GPT-4 |
| **PTU for stable workloads** | 30-50% | Kjøp PTU hvis >80% utilization |
| **Fine-tuning cleanup** | 100% på inaktive | Automatisk sletting av deployments med 0 requests/7d |
| **Batch processing** | 20-30% | Gruppér requests for å redusere overhead |

### Gateway-kostnader (Azure API Management)

| Tier | Pris/mnd | Max throughput | Bruksområde |
|------|---------|----------------|-------------|
| **Consumption** | $0.035/10k calls + $3.5/GB | 1000 req/sec | Lavt volum, sporadisk bruk |
| **Basic** | $140 | 1000 req/sec | Dev/test, interne apps |
| **Standard** | $700 | 2500 req/sec | Produksjon, multi-tenant |
| **Premium** | $2800 | 4000 req/sec | Enterprise, global distribution |

**Optimaliseringstips:**
- Start med Consumption tier for POC/pilot
- Oppgradér til Standard når throughput >100 req/sec
- Bruk Premium kun hvis multi-region deployment er påkrevd

---

## For arkitekten (Cosmo)

### Spørsmål å stille kunden

1. **Chargeback-behov:** Trenger vi å fordele kostnader per team, prosjekt eller kunde?
2. **Kostnadskontroll:** Hva er maksimal månedlig budsjett, og hva skjer hvis vi overskrider?
3. **Granularitet:** Trenger vi kostnad per bruker/API-nøkkel, eller holder det med ressursgruppe-nivå?
4. **Real-time alerts:** Hvor raskt må vi reagere på kostnadsøkninger? (24t, 1t, sanntid)
5. **3rd-party modeller:** Bruker vi Azure Marketplace-modeller (Cohere, Meta), eller kun Microsoft OpenAI?
6. **Retention:** Hvor lenge må vi lagre kostnadsdata for compliance/auditing? (90 dager, 1 år, 5 år)
7. **Export-behov:** Trenger finans-teamet data i Excel/Power BI, eller holder Azure-portalen?
8. **Gateway:** Har vi allerede Azure API Management, eller må det anskaffes?

### Fallgruver

| Fallgruve | Hvorfor det skjer | Konsekvens |
|-----------|------------------|------------|
| **Scope Cost Analysis til feil nivå** | Tror Azure OpenAI-ressurs viser alle kostnader | Mangler Marketplace-meters |
| **Glemmer fine-tuning hosting costs** | Fokuserer kun på inference-tokens | Kontinuerlige timekostnader selv uten bruk |
| **Ikke setter tag inheritance** | Manuell tagging per ressurs | Tags mangler på child-ressurser |
| **Over-logging til Azure Monitor** | Aktiverer alle diagnostic categories | Høye storage-kostnader ($100-500/mnd) |
| **Ikke sammenligner PTU vs PAYG** | Går for pay-as-you-go uten analyse | Betaler 2-3x mer for stabile workloads |
| **Mangler budsjett-alerts** | Tenker at de skal "holde øye med" kostnadene | Overskridelser oppdages for sent (neste måned) |

### Anbefalinger per modenhetsnivå

#### Modenhetsnivå 1: Proof of Concept / Pilot
- **Kostnadsstrategi:** Native Cost Analysis (gratis)
- **Budsjett:** Sett monthly budget ($500-2000) med 80% alert
- **Tagging:** Bruk minimum tags: `Environment=Dev`, `Project=POC`
- **Gateway:** Ikke nødvendig (kun 1-2 applikasjoner)
- **Review frequency:** Månedlig

#### Modenhetsnivå 2: Produksjon (Single-tenant)
- **Kostnadsstrategi:** Tag-based allocation + budsjett per prosjekt
- **Budsjett:** Separate budgets for Dev/Test/Prod environments
- **Tagging:** Fullt tagskjema (Project, CostCenter, Owner, Environment)
- **Gateway:** Vurdér APIM Consumption tier hvis >5 applikasjoner
- **Review frequency:** Ukentlig

#### Modenhetsnivå 3: Enterprise / Multi-tenant
- **Kostnadsstrategi:** Gateway (APIM Standard/Premium) + Azure Monitor
- **Budsjett:** Per-tenant budgets med automated alerts
- **Tagging:** Custom tags per kunde/abonnement
- **Gateway:** APIM Standard med KQL queries for chargeback
- **Export:** Scheduled export til Power BI for executive dashboards
- **Review frequency:** Daglig (automated dashboards)

#### Modenhetsnivå 4: Offentlig sektor (Norge)
- **Kostnadsstrategi:** Full enterprise stack + compliance-logging
- **GDPR:** IP-masking i gateway logs
- **Retention:** 5 år (Arkivlova)
- **Storage:** Norge East/West (datasuverenitet)
- **Auditing:** Export til revisjonssystem (KOSTRA-rapportering)
- **Review frequency:** Daglig + kvartalsvise audits

---

## Kilder og verifisering

### Kilder (Microsoft Learn)

1. **Plan to manage costs for Azure OpenAI**
   https://learn.microsoft.com/en-us/azure/ai-foundry/openai/how-to/manage-costs
   *Konfidensgrad: Verified* – Komplett guide for cost management (budgets, alerts, export)

2. **Azure OpenAI gateway monitoring**
   https://learn.microsoft.com/en-us/azure/architecture/ai-ml/guide/azure-openai-gateway-monitoring
   *Konfidensgrad: Verified* – Gateway-arkitektur for cost attribution og chargeback

3. **Governance for AI workloads (IaaS)**
   https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/scenarios/ai/infrastructure/governance#cost-management
   *Konfidensgrad: Verified* – Tags, billing accounts, autoscaling for AI workloads

4. **Manage AI costs (Cloud Adoption Framework)**
   https://learn.microsoft.com/en-us/azure/cloud-adoption-framework/scenarios/ai/manage#manage-ai-costs
   *Konfidensgrad: Verified* – Best practices for TPM/RPM monitoring, commitment billing

5. **Plan and manage costs for Azure AI Foundry**
   https://learn.microsoft.com/en-us/azure/ai-foundry/concepts/manage-costs
   *Konfidensgrad: Verified* – Marketplace models, fine-tuning costs, HTTP error billing

6. **Azure Cost Management API (Python SDK)**
   https://learn.microsoft.com/en-us/python/api/overview/azure/mgmt-costmanagement-readme
   *Konfidensgrad: Verified* – Programmatic access to cost data

### Konfidensgrad per seksjon

| Seksjon | Konfidensgrad | Kilde |
|---------|--------------|-------|
| Native Cost Monitoring | Verified | Microsoft Learn (manage-costs) |
| Tag-Based Allocation | Verified | Microsoft Learn (governance) |
| Gateway-Based Attribution | Verified | Azure Architecture Center |
| Multi-Model Tracking | Verified | Microsoft Learn (AI Foundry manage-costs) |
| Azure OpenAI meters | Verified | Microsoft Learn (pricing page) |
| APIM pricing | Verified | Azure Pricing Calculator |
| GDPR/IP-masking | Baseline | Generell GDPR-kunnskap + APIM policy best practices |
| Offentlig sektor retention | Baseline | Arkivlova (egen kunnskap) |

**Totalvurdering:** 90% Verified (MCP-research), 10% Baseline (domeneekspertise).

---

**For Cosmo:** Bruk denne guiden for å designe kostnadsstrategien basert på kundens modenhetsnivå. Start alltid med Native Cost Analysis + tags, og bygg ut mot gateway-løsning kun hvis chargeback eller detaljert tracking er nødvendig. Husk at fine-tuning hosting costs er en vanlig kostnadsfelle som må adresseres tidlig i prosjektet.