Ce document a été traduit à l'aide d'une technologie de traduction automatique. Bien que nous nous efforcions de fournir des traductions exactes, nous ne fournissons aucune garantie quant à l'exhaustivité, l'exactitude ou la fiabilité du contenu traduit. En cas de divergence, la version originale anglaise prévaut et fait foi.

Il s'agit d'une documentation non publiée pour Admission Controller 1.36-dev.

Écrire la logique de validation

Critique : Ne pas écrire d’informations de journalisation sur STDOUT.

Écrire sur STDOUT enfreint les stratégies. Utilisez plutôt STDERR pour la journalisation ou le service de journalisation fourni par le SUSE Security Admission Controller SDK. La sortie de la stratégie vers STDOUT ne doit contenir que la réponse de validation.

La logique de validation va dans le fichier src/index.ts.

Votre logique de validation doit :

  • Obtenir les informations pertinentes de la requête de validation entrante.

  • Renvoyer une réponse basée sur l’entrée et les paramètres de la stratégie.

La requête entrante contient un objet JSON avec la ressource Kubernetes à valider. Vous pouvez accéder aux données de cet objet JSON via les fonctions auxiliaires du Admission Controller SDK.

La fonction validate

La stratégie fournie par le modèle a déjà une fonction validate dans src/index.ts. Vous pouvez l’utiliser là, en ajoutant votre logique pour rejeter les Pods avec des noms d’hôtes refusés.

Voici à quoi la fonction devrait ressembler une fois terminée :

/**
 * Validates the incoming request against policy settings.
 * Accepts or rejects the request based on denied hostnames.
 */
function validate(): void {
  try {
    // NOTE 1
    // Read the validation request payload
    const validationRequest = Validation.Validation.readValidationRequest();

    // NOTE 2
    // Extract policy settings from the validation request
    const settings: PolicySettings = validationRequest.settings || {};

    // NOTE 3
    // Extract the Kubernetes object (Pod) from the validation request
    const resource = getKubernetesResource(validationRequest);
    if (!resource) {
      writeOutput(Validation.Validation.rejectRequest('Failed to parse Kubernetes resource.'));
      return;
    }

    // Only process Pod resources
    if (resource.kind !== 'Pod') {
      writeOutput(Validation.Validation.acceptRequest());
      return;
    }

    // NOTE 4
    // Extract hostname from the Pod spec
    const hostname = getPodHostname(resource as Pod);
    const deniedHostnames = settings.denied_hostnames || [];

    // NOTE 5
    // Validate the hostname against the deny list
    if (!hostname) {
      writeOutput(Validation.Validation.acceptRequest());
      return;
    }

    if (deniedHostnames.includes(hostname)) {
      writeOutput(
        Validation.Validation.rejectRequest(
          `+Pod hostname '${hostname}' is not allowed. Denied hostnames: [${deniedHostnames.join(', ')}]+`
        ),
      );
    } else {
      writeOutput(Validation.Validation.acceptRequest());
    }
  } catch (err) {
    console.error('Validation error:', err);
    writeOutput(Validation.Validation.rejectRequest(`+Validation failed: ${err}+`));
  }
}

Ce que fait chaque REMARQUE

  • REMARQUE 1 : Lisez la demande de validation entrante en utilisant readValidationRequest().

  • REMARQUE 2 : Extrayez les paramètres définis par l’utilisateur de la demande de validation (par exemple, les noms d’hôtes refusés).

  • REMARQUE 3 : Analysez l’objet Kubernetes (qui devrait être un Pod) à partir de la charge utile de la demande.

  • REMARQUE 4 : Extrayez le champ nom d’hôte de la section spécification du Pod.

  • REMARQUE 5 : Comparez le nom d’hôte avec la liste des refus et renvoyez une réponse appropriée.

Fonctions auxiliaires

La stratégie utilise plusieurs fonctions auxiliaires pour traiter la demande de validation :

getKubernetesResource

Cette fonction extrait la ressource Kubernetes de la demande de validation :

/**
 * Safely parses and extracts the Kubernetes resource from the validation request.
 *
 * @param {ValidationRequest} validationRequest - The validation request object.
 * @returns {KubernetesResource | undefined} The parsed Kubernetes resource if available.
 */
function getKubernetesResource(validationRequest: ValidationRequest): KubernetesResource | undefined {
  try {
    let requestObject: string | KubernetesResource | undefined = validationRequest.request?.object;
    if (typeof requestObject === 'string') {
      requestObject = JSON.parse(requestObject) as unknown as KubernetesResource;
    } else if (requestObject === undefined) {
      return undefined;
    }
    return requestObject as KubernetesResource;
  } catch (error) {
    console.error('Error parsing Kubernetes resource:', error);
    return undefined;
  }
}

Cette fonction gère le cas où l’objet Kubernetes est une chaîne JSON ou un objet déjà analysé.

getPodHostname

Cette fonction extrait le nom d’hôte d’une ressource Pod :

/**
 * Extracts the hostname from a Pod resource.
 *
 * @param {Pod} pod - The Pod resource.
 * @returns {string | undefined} The hostname if set, otherwise undefined.
 */
import type { Pod } from 'kubernetes-types/core/v1';
function getPodHostname(pod: Pod): string | undefined {
  return pod.spec?.hostname;
}

Cette fonction extrait le nom d’hôte de la spécification du Pod.

Point d’entrée de la stratégie

La stratégie utilise une instruction switch pour gérer différentes actions :

const action = policyAction();
switch (action) {
  case 'validate':
    validate();
    break;
  case 'validate-settings':
    validateSettings();
    break;
  default:
    console.error('Unknown action:', action);
    writeOutput(new Validation.Validation.ValidationResponse(false, 'Unknown policy action'));
}

Le Admission Controller plug-in Javy fournit la fonction policyAction() indiquant si la stratégie doit valider une ressource ou valider ses paramètres.