---
title: Kubernetes
description: Exécutez Human Plugin sur Kubernetes avec un Deployment, un Service ClusterIP, un Secret pour les paramètres et un secret de pull pour le registre d'Unico.
canonical: https://developer.unico.io/fr/human-plugin/self-hosting/kubernetes
locale: fr
generated_by: markdown-export
---

# Kubernetes

Au moins deux réplicas derrière un Service ClusterIP, accessibles uniquement depuis votre back-end.

## Prérequis

- Un cluster Kubernetes et un accès `kubectl` à celui-ci.
- Une base de données PostgreSQL dédiée à Human Plugin, accessible depuis le cluster. Voir [Prérequis et accès](/fr/human-plugin/get-started/prerequisites).
- Les identifiants du registre et la clé d'accès fournis par Unico.

Tout ce qui suit se place dans un namespace dédié :

```bash
kubectl create namespace human-plugin
```

## 1. Secret de pull du registre

```bash
kubectl -n human-plugin create secret docker-registry unico-registry \
  --docker-server=pkg.unico.run \
  --docker-username="<username>" \
  --docker-password="<token>"
```

## 2. Secret des paramètres

```bash
kubectl -n human-plugin create secret generic human-plugin \
  --from-literal=HUMAN_API_ACCESS_KEY='<your access key>' \
  --from-literal=POSTGRES_ADDRESS_HOST='<database host>' \
  --from-literal=POSTGRES_USER='human_plugin' \
  --from-literal=POSTGRES_PASSWORD='<database password>'
```

Ajoutez `POSTGRES_ADDRESS_PORT`, `POSTGRES_DATABASE` ou `POSTGRES_SSL_MODE` uniquement si votre base de données diffère des valeurs par défaut décrites dans [Configuration](/fr/human-plugin/self-hosting/configuration). Si vous gérez les secrets avec un autre outil (External Secrets, Sealed Secrets, un coffre-fort), créez les mêmes clés avec celui-ci. Ne versionnez jamais un manifeste Secret contenant des valeurs.

## 3. Deployment et Service

```yaml title="human-plugin.yaml"
apiVersion: apps/v1
kind: Deployment
metadata:
  name: human-plugin
  namespace: human-plugin
spec:
  replicas: 2
  selector:
    matchLabels: { app: human-plugin }
  template:
    metadata:
      labels: { app: human-plugin }
    spec:
      terminationGracePeriodSeconds: 60
      imagePullSecrets:
        - name: unico-registry
      containers:
        - name: human-plugin
          image: pkg.unico.run/human-plugin-api:latest
          imagePullPolicy: Always
          ports:
            - { name: http, containerPort: 8080 }
          envFrom:
            - secretRef: { name: human-plugin }
          resources:
            requests: { cpu: "1", memory: 1Gi }
            limits: { cpu: "1", memory: 1Gi }
          readinessProbe:
            httpGet: { path: /health/ready, port: http }
            timeoutSeconds: 5
          livenessProbe:
            httpGet: { path: /health/live, port: http }
            periodSeconds: 30
---
apiVersion: v1
kind: Service
metadata:
  name: human-plugin
  namespace: human-plugin
spec:
  selector: { app: human-plugin }
  ports:
    - { name: http, port: 8080, targetPort: http }
```

```bash
kubectl apply -f human-plugin.yaml
```

```bash
kubectl -n human-plugin rollout status deployment/human-plugin
```

- **`replicas: 2` :** les réplicas partagent la base de données, vous pouvez donc en exécuter autant que nécessaire. Deux réplicas maintiennent Human Plugin disponible pendant le redémarrage de l'un d'eux.
- **`terminationGracePeriodSeconds: 60` :** à l'arrêt, Human Plugin attend jusqu'à 55 secondes les requêtes en cours. La valeur par défaut de Kubernetes, 30 secondes, peut interrompre une création.
- **`imagePullPolicy: Always` :** avec le tag `latest`, chaque nouveau Pod récupère la version la plus récente.
- **Sondes :** la readiness maintient le trafic à l'écart d'un réplica tant que sa base de données ne répond pas, et `timeoutSeconds: 5` la fait échouer lorsque la base cesse de répondre. Voir [Santé et supervision](/fr/human-plugin/self-hosting/health-and-monitoring).
- **Ressources :** les valeurs ci-dessus sont le minimum pour chaque réplica. Voir [Configuration matérielle requise](/fr/human-plugin/self-hosting/overview#hardware-requirements).

## 4. Restreindre l'accès

Votre back-end accède à Human Plugin à l'adresse `http://human-plugin.human-plugin.svc:8080`. Human Plugin n'a pas d'authentification propre, donc :

- n'exposez pas le Service via un Ingress, un `LoadBalancer` ou un `NodePort` ;
- n'autorisez que le namespace de votre back-end avec une NetworkPolicy.

```yaml title="network-policy.yaml"
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: human-plugin-allow-backend
  namespace: human-plugin
spec:
  podSelector:
    matchLabels: { app: human-plugin }
  policyTypes: [Ingress]
  ingress:
    - from:
        - namespaceSelector:
            matchLabels: { kubernetes.io/metadata.name: <your back-end namespace> }
      ports:
        - { port: 8080 }
```

Human Plugin lui-même a besoin d'un accès HTTPS sortant vers Unico et d'un accès à votre base de données. Voir [Réseau et sécurité](/fr/human-plugin/self-hosting/networking-and-security).

## 5. Valider

```bash
kubectl -n human-plugin port-forward svc/human-plugin 8080:8080
```

Dans un autre terminal, vérifiez la readiness et exécutez la requête de création du [Démarrage rapide](/fr/human-plugin/get-started/quickstart#3-create-a-process) sur `http://127.0.0.1:8080` :

```bash
curl --fail http://127.0.0.1:8080/health/ready
```

## Journaux

```bash
kubectl -n human-plugin logs deploy/human-plugin --since=10m
```

## Mise à jour

```bash
kubectl -n human-plugin rollout restart deployment/human-plugin
```

Les nouveaux Pods récupèrent la dernière image et remplacent les anciens un par un, dès qu'ils sont prêts. Voir [Exploitation](/fr/human-plugin/self-hosting/operations).