concetti kro

kro consente ai team della piattaforma di creare Kubernetes personalizzati APIs che compongono più risorse in astrazioni di livello superiore. Questo argomento illustra un esempio pratico, quindi spiega i concetti fondamentali da comprendere quando si lavora con EKS Capability for kro.

Guida introduttiva a kro

Dopo aver creato la funzionalità kro (vediCrea una funzionalità kro), puoi iniziare a crearne un APIs utilizzo personalizzato ResourceGraphDefinitions nel tuo cluster.

Ecco un esempio completo che crea una semplice astrazione di un'applicazione web:

apiVersion: kro.run/v1alpha1
kind: ResourceGraphDefinition
metadata:
  name: webapplication
spec:
  schema:
    apiVersion: v1alpha1
    kind: WebApplication
    group: kro.run
    spec:
      name: string | required=true
      image: string | default="nginx:latest"
      replicas: integer | default=3
  resources:
  - id: deployment
    template:
      apiVersion: apps/v1
      kind: Deployment
      metadata:
        name: ${schema.spec.name}
      spec:
        replicas: ${schema.spec.replicas}
        selector:
          matchLabels:
            app: ${schema.spec.name}
        template:
          metadata:
            labels:
              app: ${schema.spec.name}
          spec:
            containers:
            - name: app
              image: ${schema.spec.image}
              ports:
              - containerPort: 80
  - id: service
    template:
      apiVersion: v1
      kind: Service
      metadata:
        name: ${schema.spec.name}
      spec:
        selector:
          app: ${schema.spec.name}
        ports:
        - protocol: TCP
          port: 80
          targetPort: 80

Dopo averlo applicato ResourceGraphDefinition, i team applicativi possono creare applicazioni Web utilizzando la vostra API semplificata:

apiVersion: kro.run/v1alpha1
kind: WebApplication
metadata:
  name: my-app
spec:
  name: my-app
  replicas: 5

kro crea automaticamente Deployment and Service con la configurazione appropriata. Poiché image non è specificato, utilizza il valore predefinito nginx:latest dello schema.

Concetti principali

Importante

kro esegue la convalida ResourceGraphDefinitions al momento della creazione, non in fase di esecuzione. Quando crei un RGD, kro convalida la sintassi CEL, controlla il tipo delle espressioni rispetto agli schemi Kubernetes effettivi, verifica l'esistenza dei campi e rileva le dipendenze circolari. Ciò significa che gli errori vengono rilevati immediatamente quando si crea l'RGD, prima che qualsiasi istanza venga distribuita.

ResourceGraphDefinition

A ResourceGraphDefinition (RGD) definisce un'API Kubernetes personalizzata specificando:

• Schema: la struttura dell'API che utilizza il SimpleSchema formato (nomi di campo, tipi, impostazioni predefinite, convalida)

• Risorse: modelli per il Kubernetes sottostante o risorse da creare AWS

• Dipendenze: come le risorse si relazionano tra loro (rilevate automaticamente dai riferimenti di campo)

Quando applichi un RGD, kro registra una nuova Custom Resource Definition (CRD) nel tuo cluster. I team applicativi possono quindi creare istanze della vostra API personalizzata e kro si occupa della creazione e della gestione di tutte le risorse sottostanti.

Per ulteriori informazioni, consulta ResourceGraphDefinition Panoramica nella documentazione di kro.

SimpleSchema formato

SimpleSchema fornisce un modo semplificato per definire gli schemi API senza richiedere conoscenze su OpenAPI:

schema:
  apiVersion: v1alpha1
  kind: Database
  spec:
    name: string | required=true description="Database name"
    size: string | default="small" enum=small,medium,large
    replicas: integer | default=1 minimum=1 maximum=5

SimpleSchema supportastring, integerboolean, e number tipi con vincoli comerequired,,/default, minimum e. maximum enum pattern

Per ulteriori informazioni, consulta la documentazione SimpleSchemadi kro.

espressioni CEL

kro utilizza il Common Expression Language (CEL) per fare riferimento ai valori in modo dinamico e aggiungere logica condizionale. Le espressioni CEL sono racchiuse ${ } e possono essere utilizzate in due modi:

Espressioni autonome - L'intero valore del campo è una singola espressione:

spec:
  replicas: ${schema.spec.replicaCount}  # Expression returns integer
  labels: ${schema.spec.labelMap}        # Expression returns object

Il risultato dell'espressione sostituisce l'intero valore del campo e deve corrispondere al tipo previsto del campo.

Modelli di stringhe: una o più espressioni incorporate in una stringa:

metadata:
  name: "${schema.spec.prefix}-${schema.spec.name}"  # Multiple expressions
  annotation: "Created by ${schema.spec.owner}"      # Single expression in string

Tutte le espressioni nei modelli di stringhe devono restituire stringhe. Usa string() per convertire altri tipi:"replicas-${string(schema.spec.count)}".

Riferimenti sui campi: accedi ai valori delle specifiche dell'istanza utilizzandoschema.spec:

template:
  metadata:
    name: ${schema.spec.name}-deployment
    namespace: ${schema.metadata.namespace}  # Can also reference metadata
  spec:
    replicas: ${schema.spec.replicas}

Accesso facoltativo ai campi: da utilizzare ? per campi che potrebbero non esistere:

# For ConfigMaps or Secrets with unknown structure
value: ${configmap.data.?DATABASE_URL}

# For optional status fields
ready: ${deployment.status.?readyReplicas > 0}

Se il campo non esiste, l'espressione restituisce null invece di fallire.

Risorse condizionali: includi le risorse solo quando sono soddisfatte le condizioni:

resources:
- id: ingress
  includeWhen:
    - ${schema.spec.enableIngress == true}
  template:
    # ... ingress configuration

Il includeWhen campo accetta un elenco di espressioni booleane. Tutte le condizioni devono essere vere affinché la risorsa possa essere creata. Attualmente, includeWhen può fare riferimento solo schema.spec ai campi.

Trasformazioni - Trasforma i valori utilizzando operatori e funzioni ternari:

template:
  spec:
    resources:
      requests:
        memory: ${schema.spec.size == "small" ? "512Mi" : "2Gi"}

    # String concatenation
    image: ${schema.spec.registry + "/" + schema.spec.imageName}

    # Type conversion
    port: ${string(schema.spec.portNumber)}

Riferimenti tra risorse - Valori di riferimento provenienti da altre risorse:

resources:
- id: bucket
  template:
    apiVersion: s3.services.k8s.aws/v1alpha1
    kind: Bucket
    spec:
      name: ${schema.spec.name}-data

- id: configmap
  template:
    apiVersion: v1
    kind: ConfigMap
    data:
      BUCKET_NAME: ${bucket.spec.name}
      BUCKET_ARN: ${bucket.status.ackResourceMetadata.arn}

Quando si fa riferimento a un'altra risorsa in un'espressione CEL, si crea automaticamente una dipendenza. kro assicura che la risorsa referenziata venga creata per prima.

Per ulteriori informazioni, consulta CEL Expressions nella documentazione di kro.

Dipendenze tra le risorse

kro deduce automaticamente le dipendenze dalle espressioni CEL: non si specifica l'ordine, si descrivono le relazioni. Quando una risorsa fa riferimento a un'altra utilizzando un'espressione CEL, kro crea una dipendenza e determina l'ordine di creazione corretto.

resources:
- id: bucket
  template:
    apiVersion: s3.services.k8s.aws/v1alpha1
    kind: Bucket
    spec:
      name: ${schema.spec.name}-data

- id: notification
  template:
    apiVersion: s3.services.k8s.aws/v1alpha1
    kind: BucketNotification
    spec:
      bucket: ${bucket.spec.name}  # Creates dependency: notification depends on bucket

L'espressione ${bucket.spec.name} crea una dipendenza. kro crea un grafico aciclico diretto (DAG) di tutte le risorse e le relative dipendenze, quindi calcola un ordine topologico per la creazione.

Ordine di creazione: le risorse vengono create in ordine topologico (prima le dipendenze).

Creazione parallela: le risorse senza dipendenze vengono create contemporaneamente.

Ordine di eliminazione: le risorse vengono eliminate in ordine topologico inverso (prima le persone dipendenti).

Dipendenze circolari: non consentite: kro rifiuta con dipendenze circolari durante la convalida. ResourceGraphDefinitions

È possibile visualizzare l'ordine di creazione calcolato:

kubectl get resourcegraphdefinition my-rgd -o jsonpath='{.status.topologicalOrder}'

Per maggiori informazioni, vedi Inferenza del grafico nella documentazione di kro.

Composizione con ACK

kro funziona perfettamente con EKS Capability for ACK per comporre AWS risorse con risorse Kubernetes:

resources:
# Create {aws} S3 bucket with ACK
- id: bucket
  template:
    apiVersion: s3.services.k8s.aws/v1alpha1
    kind: Bucket
    spec:
      name: ${schema.spec.name}-files

# Inject bucket details into Kubernetes ConfigMap
- id: config
  template:
    apiVersion: v1
    kind: ConfigMap
    data:
      BUCKET_NAME: ${bucket.spec.name}
      BUCKET_ARN: ${bucket.status.ackResourceMetadata.arn}

# Use ConfigMap in application deployment
- id: deployment
  template:
    apiVersion: apps/v1
    kind: Deployment
    spec:
      template:
        spec:
          containers:
          - name: app
            envFrom:
            - configMapRef:
                name: ${config.metadata.name}

Questo modello consente di creare AWS risorse, estrarne i dettagli (ARNs URLs, endpoint) e inserirle nella configurazione dell'applicazione, il tutto gestito come una singola unità.

Per ulteriori schemi di composizione ed esempi avanzati, consulta. considerazioni kro per EKS

Fasi successive

• considerazioni kro per EKS- Scopri i pattern specifici di EKS, l'RBAC e l'integrazione con ACK e Argo CD

• kro Documentation - Documentazione kro completa che include espressioni CEL avanzate, modelli di convalida e risoluzione dei problemi