Préparation des images de conteneur

Pour les images, le service d'intelligence artificielle générative prend en charge l'architecture x86 64 bits, nom de code amd64. Lors de la création d'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 s'exécuter dans l'environnement de déploiement hébergé.

Hôte et port

• Le conteneur doit être à l'écoute sur l'hôte 0.0.0.0.
• Le conteneur doit être à l'écoute sur le port 8080.

Type de contenu de réponse HTTP

Le conteneur doit exposer un service HTTP qui met en oeuvre des points d'extrémité 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 diffusion en continu en inspectant l'en-tête Accepter.

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

Cette configuration prend en charge un point d'extrémité pour les interactions en continu et non en continu d'une manière cohérente et rétrocompatible.

Point d'extrémité de préparation

Le conteneur Docker doit exposer un point d'extrémité de disponibilité pour vérifier que l'application est entièrement initialisée et prête à traiter les demandes.

• Chemin : /ready
• Objet : 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, le point d'extrémité doit retourner un code de statut autre que 200 pour empêcher le routage du trafic.

Point d'extrémité de durée de vie

Le conteneur Docker doit exposer un point d'extrémité d'activité pour vérifier que l'application s'exécute correctement et ne nécessite pas de redémarrage.

• Chemin : /health
• Objet : 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 saine)

Si l'application passe à un état d'interblocage ou d'impossibilité de récupération, le point d'extrémité doit retourner un code d'état autre que 200 afin que la plate-forme puisse redémarrer automatiquement le conteneur.

Architecture de l'image

Le service prend en charge amd64.

Note

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

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 de 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éez l'image docker dans l'architecture amd64

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

Créez un registre de conteneurs. Voir Aperçu du registre de conteneurs.

Utilisez l'interface de ligne de commande docker pour pousser des images docker vers le registre de conteneurs.

Étape 1 : Se connecter au registre de conteneurs Exemple de code :

docker login kix.ocir.io

Étape 2 : Marquer l'image à l'aide de l'URL et de l'espace de noms du registre de conteneur. Exemple de code :

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

Étape 3 : Pousser l'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 sécurité de votre système et de réagir rapidement lorsque de nouvelles vulnérabilités sont détectées.

Voir Balayage d'images à la recherche de vulnérabilités pour créer une recette de balayage et une cible de balayage.