Préparation des images de conteneur

Pour les images, le service d'IA générative prend en charge l'architecture x86 64 bits, nom de code amd64. Lorsque vous créez des images de conteneur, utilisez linux/amd64 comme type de plate-forme.

Par exemple :

docker buildx build --platform linux/amd64 -t myimage:latest

Le conteneur Docker doit répondre aux exigences suivantes pour être exécuté dans l'environnement de déploiement hébergé.

Hôte et Port

• Le conteneur doit écouter sur l'hôte 0.0.0.0.
• Le conteneur doit écouter sur le port 8080.

Type du contenu de réponse HTTP

Le conteneur doit exposer un service HTTP qui implémente des adresses de demande et de réponse de type REST à l'aide de méthodes telles que GET, PUT, POST, DELETE et PATCH avec des chemins définis par l'utilisateur.

La plate-forme détermine si une demande attend une réponse de transmission en continu en examinant l'en-tête Accept.

• Si l'en-tête Accept inclut text/event-stream, l'adresse doit renvoyer une réponse SSE (Server-Sent Events) avec le type de contenu text/event-stream.
• Sinon, l'adresse doit renvoyer une réponse JSON standard avec le type de contenu application/json.

Cette configuration prend en charge une adresse pour les interactions de transmission en continu et non en continu de manière cohérente et rétrocompatible.

Adresse de préparation

Le conteneur Docker doit exposer une adresse de préparation pour vérifier que l'application est entièrement initialisée et prête à traiter les demandes.

• Chemin : /ready
• Objectif : indique si le conteneur est prêt à recevoir le trafic
• Format de réponse : code de statut HTTP uniquement
• Type de contenu : application/json
• Code de statut de réussite : 200 OK (l'application est prête)

Si le conteneur n'est pas prêt, l'adresse doit renvoyer un code de statut autre que 200 pour empêcher le routage du trafic.

Endpoint de vie

Le conteneur Docker doit exposer une adresse de diffusion pour vérifier que l'application fonctionne correctement et ne nécessite pas de redémarrage.

• Chemin : /health
• Objectif : détecte si le conteneur est actif et fonctionnel
• Format de réponse : code de statut HTTP uniquement
• Type de contenu : application/json
• Code de statut de réussite : 200 OK (l'application est en bon état)

Si l'application entre dans un interblocage ou un état irrécupérable, l'adresse doit renvoyer un code d'état autre que 200 afin que la plate-forme puisse redémarrer le conteneur automatiquement.

Architecture d'image

Le service prend en charge amd64.

Remarque

Nous vous recommandons d'utiliser les images de base fournies par Oracle Container Registry. Les images de ce site passent l'analyse des vulnérabilités.

Variables d'environnement réservées

Les variables d'environnement suivantes sont réservées à l'utilisation du système. Ne les définissez pas dans le code conteneur :

PORT
K_SERVICE
K_CONFIGURATION
K_REVISION
OCI_RESOURCE_PRINCIPAL_VERSION
OCI_RESOURCE_PRINCIPAL_PRIVATE_PEM
OCI_RESOURCE_PRINCIPAL_RPST
KUBERNETES_*

from contextlib import asynccontextmanager
import os
import sys
from typing import Any, Dict

from dotenv import load_dotenv
from fastapi import FastAPI
from langchain_core.messages import HumanMessage
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver
from langgraph.prebuilt import create_react_agent

load_dotenv()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
TEMPERATURE = float(os.getenv("OPENAI_TEMPERATURE", "0.7"))
OPENAI_MOCK_MODE_ENV = os.getenv("OPENAI_MOCK_MODE")
if OPENAI_MOCK_MODE_ENV is None:
    OPENAI_MOCK_MODE = not bool(OPENAI_API_KEY)
else:
    OPENAI_MOCK_MODE = OPENAI_MOCK_MODE_ENV.strip().lower() in (
        "1",
        "true",
        "yes",
        "on",
    )

app_graph = None


@asynccontextmanager
async def lifespan(app: FastAPI):
    global app_graph

    if OPENAI_MOCK_MODE and not OPENAI_API_KEY:
        print(
            "OPENAI_API_KEY is not set; running in OPENAI_MOCK_MODE.",
            file=sys.stderr,
        )
        yield
        return

    if not OPENAI_API_KEY:
        raise RuntimeError("OPENAI_API_KEY is not set in environment.")

    model = ChatOpenAI(
        model=OPENAI_MODEL,
        temperature=TEMPERATURE,
        api_key=OPENAI_API_KEY,
        streaming=True,
    )
    app_graph = create_react_agent(
        model=model,
        tools=[],
        checkpointer=MemorySaver(),
    )
    yield


app = FastAPI(lifespan=lifespan)


@app.post("/chat")
async def chat(body: Dict[str, Any]):
    thread_id = body["thread_id"]
    msg = body["message"]

    if OPENAI_MOCK_MODE and not OPENAI_API_KEY:
        return {
            "reply": f"[MOCK] OPENAI_API_KEY missing. Echo: {msg}",
            "thread_id": thread_id,
        }

    response = await app_graph.ainvoke(
        {"messages": [HumanMessage(content=msg)]},
        config={"configurable": {"thread_id": thread_id}},
    )

    if "messages" in response and response["messages"]:
        last_message = response["messages"][-1]
        ai_content = getattr(last_message, "content", str(last_message))
    else:
        ai_content = "I'm not sure how to respond to that."

    return {"reply": ai_content}


@app.get("/health")
async def health():
    return {
        "status": "Healthy",
        "mode": "mock" if (OPENAI_MOCK_MODE and not OPENAI_API_KEY) else "normal",
    }


@app.get("/ready")
async def ready():
    if OPENAI_MOCK_MODE and not OPENAI_API_KEY:
        return {"status": "Ready", "mode": "mock"}
    return {"status": "Ready"}

project_directory/
├── agent_example.py # Your main agent code
├── pyproject.toml # Dependencies for your agent
├── Dockerfile # docker file for building image
├── uv.lock # auto generated by uv
└── __init__.py # Makes the directory a Python package

Voici un exemple de fichier Docker dans un répertoire de projet.

FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv

# Copy project files
COPY pyproject.toml uv.lock ./
COPY *.py ./


# Install dependencies using uv
RUN uv sync --frozen

# Expose port
EXPOSE 8080

# Run the application using uv
CMD ["uv", "run", "python", "agent_example.py"]

Créer l'image docker dans l'architecture amd64

docker buildx build --platform linux/amd64 -t my_agent:v1 .

Créez un registre de conteneurs. Reportez-vous à Présentation de Container Registry.

Utilisez l'interface de ligne de commande docker pour propager des images docker vers le registre de conteneur.

Etape 1 : connexion au registre de conteneurs Exemple de code :

docker login kix.ocir.io

Etape 2 : balisage de l'image à l'aide de l'URL et de l'espace de noms du registre de conteneurs. Exemple de code :

docker tag my_agent:v1 ap-osaka-1.ocir.io/{your_tenancy_namespace}/my_agent:v1

Etape 3 : Push image Exemple de code :

docker push ap-osaka-1.ocir.io/<your_tenancy_namespace>/my_agent:v1

Il n'est pas rare que les packages du système d'exploitation inclus dans les images présentent des vulnérabilités. La gestion de ces vulnérabilités vous permet de renforcer la posture de sécurité de votre système et de réagir rapidement lorsque de nouvelles vulnérabilités sont détectées.

Pour créer une recette d'analyse et une cible d'analyse, reportez-vous à Analyse des images à la recherche de vulnérabilités.