Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Skydda din API-nyckel: Exponera den aldrig på klientsidan

Lektion 6 av 12 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. En API-nyckel är ett lösenord
  2. Vanliga exponeringsvägar
  3. Proxyarkitektur: Lösningen
  4. Säker lagring av nycklar
  5. Vad du ska göra om din nyckel komprometteras
  6. Viktiga punkter

En API-nyckel är ett lösenord

Din xAI-API-nyckel fungerar som ett lösenord med full tillgång till ditt konto. Alla som har den kan göra API-anrop på din bekostnad, komma åt dina modeller och potentiellt äventyra dina data. Hur skiljer den sig från ett vanligt lösenord? En stulen nyckel kan användas i tysthet: du märker ingenting förrän fakturan kommer, eller tills ditt ekonomiteam larmar. Regeln är enkel och absolut: exponera aldrig en API-nyckel på klientsidan.

Vanliga exponeringsvägar

Det vanligaste fallet är direkt inkludering av nyckeln i frontend-JavaScript:

// FARA – gör ALDRIG så här
const response = await fetch("https://api.x.ai/v1/chat/completions", {
  headers: { "Authorization": "Bearer xai-abc123..." }
});

När koden väl är distribuerad är den synlig för alla som använder webbläsarens utvecklarverktyg. Det räcker att öppna fliken Network för att läsa nyckeln i klartext i begärandehuvudena.

En mer lömsk väg, eftersom den ger en falsk känsla av säkerhet, är frontend-miljövariabler. Variabler med prefixen NEXT_PUBLIC_, VITE_ eller REACT_APP_ buntas in i JavaScript-koden vid byggtid och blir därmed offentliga. Utvecklaren tror att hen har “hållit nyckeln borta från koden”; i verkligheten är den helt enkelt kompilerad in i den:

# FARA – denna variabel hamnar i bunteln
NEXT_PUBLIC_XAI_API_KEY=xai-abc123...

Git-arkiv är den tredje klassiska vägen. Även ett borttaget commit finns kvar i Git-historiken: om du av misstag committat en nyckel räcker det inte att skriva om historiken, eftersom kloner och forkar kan ha behållit den. Betrakta den som komprometterad och återkalla den. Slutligen läcker nycklar också via indirekta vägar, svårare att föreställa sig men mycket vanliga: applikationsloggar som spårar hela huvuden, felmeddelanden som visas för användaren, eller övervakningsverktyg som fångar utgående begäranden.

Proxyarkitektur: Lösningen

Det enda säkra tillvägagångssättet är att proxy:a alla anrop genom din backend:

Klient (webbläsare/mobil)
    ↓ begäran utan API-nyckel
Din Backend (server)
    ↓ lägger till API-nyckel (miljövariabel)
xAI API
    ↓ svar
Din Backend
    ↓ vidarebefordrar svar (filtrerat vid behov)
Klient

Här är en minimalistisk proxy i Python:

# Python Backend (Flask)
import os
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)
XAI_KEY = os.environ["XAI_API_KEY"]  # Endast server-side variabel

@app.route("/api/chat", methods=["POST"])
def proxy_chat():
    user_message = request.json.get("message")

    response = requests.post(
        "https://api.x.ai/v1/chat/completions",
        headers={"Authorization": f"Bearer {XAI_KEY}"},
        json={
            "model": "grok-4.3",
            "messages": [{"role": "user", "content": user_message}]
        }
    )

    return jsonify(response.json())

Utöver att skydda nyckeln – som aldrig överförs till klienten – ger proxyn dig en kontrollpunkt som direkta anrop omöjliggör. Du kan filtrera begäranden: hastighetsbegränsning för att förhindra att en klient tömmer din kvot, validering av indata och innehållsmoderering. Du styr vilka modeller som är tillgängliga, vilket förhindrar att en kapad klient anropar en dyr modell och genererar oväntade kostnader. Du kan logga anrop för revision – ett centralt behov för en ansvarig för efterlevnad. Och du kan cacha vissa svar för att minska kostnaderna vid repetitiva begäranden.

Säker lagring av nycklar

På serversidan är grundnivån miljövariabeln, inläst från en .env-fil som aldrig committas till Git:

# .env-fil (ALDRIG committad till Git)
XAI_API_KEY=xai-din-hemliga-nyckel

Lägg systematiskt till dessa filer i din .gitignore:

# .gitignore
.env
.env.local
.env.production

För produktionsmiljöer är en .env-fil placerad på en server fortfarande en bristfällig manuell process: föredra en dedikerad hemlighetshanterare. Beprövade alternativ inkluderar AWS Secrets Manager eller SSM Parameter Store, Google Secret Manager, Azure Key Vault, HashiCorp Vault, eller Doppler och Infisical för lättare strukturer. Vad dessa verktyg erbjuder utöver en vanlig fil: automatisk nyckelrotation, granskning av åtkomst – vem läste vilken hemlighet och när – samt kryptering i vila. Detta är element du kan presentera rakt av under en säkerhetsrevision, medan en textfil på en maskin bevisar ingenting.

Vad du ska göra om din nyckel komprometteras

Om du misstänker att en nyckel har exponerats är ordningen på åtgärderna lika viktig som åtgärderna själva. Återkalla nyckeln i xAI-konsolen (console.x.ai) före allt annat: varje minut den komprometterade nyckeln är aktiv är en minut av möjlig exploatering, och tjänstekontinuitet hanteras efteråt, inte innan. Generera sedan en ny nyckel och uppdatera dina backends för att återställa tjänsten.

Incidenten är inte avslutad än. Granska användningen genom att leta efter misstänkta API-anrop i din faktureringshistorik – en topp under ett ovanligt tidsfönster, användning tillskriven en modell du inte använder. Identifiera källan till läcket, annars kommer den nya nyckeln att följa samma väg som den gamla. Avsluta med att skanna din kod med verktyg som gitleaks eller truffleHog, som också traverserar Git-historiken och ofta avslöjar andra hemligheter som glömts bort för länge sedan.

Viktiga punkter

  • En API-nyckel är ett lösenord med full tillgång till ditt konto
  • Proxy:a alltid API-anrop genom din backend
  • Variabler med NEXT_PUBLIC_, VITE_, REACT_APP_ är offentliga
  • Använd en hemlighetshanterare i produktion
  • Om en nyckel komprometteras, återkalla den omedelbart och granska användningen