Ir al contenido
AggregaAggrega
Seleccionar idioma: Español
Esta página se tradujo automáticamente. Lee el original en inglés.

provides, inject, uses

El contrato de inyección y el mapa prerresuelto

Como Aggrega es un compilador estático de compilación anticipada (AOT), ningún dato fluye hacia atrás desde la infraestructura en ejecución durante la compilación. Es mecánicamente imposible que el compilador obtenga activamente una credencial física (como un secreto de AWS) y la pase «de vuelta» al entorno del contenedor del Desarrollador.

En cambio, la plataforma se basa en la verdadera inversión de control. Cuando un desarrollador escribe inject: { env: [{ in: ORACLE_PASSWORD, from: "password" }] }, no está iniciando una obtención de datos; está dictando un contrato estricto a la infraestructura.

  1. La intención (Dominio 1): El Desarrollador declara una interfaz abstracta: «Necesito un secreto. No sé dónde está. Simplemente inyéctalo en mi entorno como ORACLE_PASSWORD, asignado a la clave password del catálogo.»
  2. La transferencia del compilador (al renderizar): El compilador de Go toma la entrada { in: ORACLE_PASSWORD, from: "password" } y se la entrega a la Recipe de Ops. No se obtiene ningún secreto físico.
  3. La salida del Plugin (Dominio 3): La canalización Wasm de la FeatureRecipe de credenciales genera los artefactos precisos e interdependientes que requiere la infraestructura de destino. Por ejemplo, en Kubernetes, produce el CRD ExternalSecret (que indica al clúster que obtenga los datos del vault) Y ejecuta un JSONPatch sobre el Pod de destino para asignar el Secret de K8s local resultante específicamente a la variable de entorno "ORACLE_PASSWORD" solicitada por el desarrollador.
  4. La realidad en tiempo de ejecución: En tiempo de ejecución, un operador en el clúster simplemente ejecuta estos artefactos generados—obteniendo la credencial y montándola físicamente en el contenedor—, lo que desacopla por completo la mecánica física de seguridad del compilador AOT.

Para entregar esta realidad física a la aplicación sin violar la separación de responsabilidades, Aggrega utiliza el Injection Contract. Sin embargo, este contrato distingue estrictamente entre el código de aplicación personalizado y la infraestructura comercial lista para usar (COTS):

  • White-Box (código personalizado): El componente es un worker genérico (p. ej., un agente Python personalizado). El compilador de Go y la Recipe de Ops no tienen ni idea de qué variables espera el script personalizado del desarrollador. Por eso, el Desarrollador dicta la entrega mediante el bloque inject: dondequiera que el código lea nombres que su Recipe no entrega por defecto — tanto para las dependencias entre componentes (mediante uses[].inject con from: que hace referencia a los provides del destino) como para los valores propios del componente (mediante inject a nivel de componente con literales value: o from: que hace referencia a sus propios provides). Qué mecanismos se permiten se declara por superficie, y las dos declaraciones son independientes: los valores propios del componente se rigen por la lista de permitidos spec.inject (p. ej., inject: ["env", "file"]), mientras que una arista uses: se rige por la lista de permitidos del socket a través del cual está conectada, spec.usesSchema.<socket>.inject. Dictar un mecanismo que la lista de permitidos aplicable no nombra detiene la compilación en cualquiera de las dos superficies.
  • Black-Box (cómputo empaquetado): El componente es un sistema cerrado (p. ej., Redis, un API Gateway gestionado). La Recipe de Ops ya sabe exactamente cómo consume sus datos el sistema. Por eso, la entidad de catálogo del Component omite la lista de permitidos, lo que prohíbe el dictado por completo en lugar de restringirlo — omitir spec.inject prohíbe el self-inject a nivel de componente, y un socket declarado sin una lista de permitidos inject: prohíbe cualquier bloque inject: en una arista conectada a través de él. El Desarrollador simplemente proporciona el destino de la dependencia mediante uses, y la plataforma gestiona el cableado interno de forma nativa mediante el valuesMapping de la Recipe.

La regla de direccionamiento determinista (física de la red interna) La tubería .context.uses de Aggrega inyecta dinámicamente cadenas de destino en los contenedores en tiempo de compilación. Como el compilador Go central es totalmente agnóstico respecto a la red física, lo que cuenta como cadena de dirección válida depende por completo de un contrato social que mantiene Platform Ops, no de una función del compilador — el compilador canaliza cualquier cadena de puntero determinista que haya producido la Recipe de Ops hacia el contexto de plantilla posterior sin interpretarla.

La regla: la Recipe de Ops debe exportar un puntero de dirección determinista y estable. El proveedor no calcula IP. En su lugar, la Recipe de Ops del destino debería formular una cadena predecible y exponerla a través de su contrato provides: (p. ej., publicando provides.internal_host: "http://agent-b.namespace.svc.cluster.local" en Kubernetes, o una cadena de interpolación como "${module.db.endpoint}" en Terraform, donde el módulo declara un output correspondiente para el valor).

Confiar en que el compilador obtenga IP dinámicas posteriores al aprovisionamiento viola directamente el modelo de ejecución AOT. Como el compilador evalúa la topología antes de que la nube aprovisione cualquier cómputo real, no puede obtener físicamente datos que aún no existen. Si un servicio requiere una IP aleatoria que solo se genera después de que arranca el cómputo, el compilador no puede obtenerla físicamente. La única tarea del compilador es canalizar la cadena de puntero determinista proporcionada por la Recipe de Ops, tal cual, hacia las variables de entorno del contenedor que llama, dejando la resolución final al DNS del clúster o al gestor de estado de IaC activo.

Imponer de forma nativa el direccionamiento determinista resuelve las dependencias cíclicas (p. ej., el agente A delega en el agente B, y el agente B delega de vuelta en el agente A). Como la URL estable o el puntero de IaC es calculable como cadena antes de que cualquiera de los dos contenedores arranque realmente, el compilador conecta ambos agentes de forma segura sin introducir condiciones de carrera temporales.

(Nota: esta regla también se aplica al ingress externo. Si una arquitectura expone un API Gateway público y requiere que esa URL se inyecte de vuelta en un contenedor interno, el compilador de Go no puede obtener la URL aleatoria generada por la nube (p. ej., xyz123.execute-api.aws.com) porque no existe en tiempo de compilación. Ops debe escribir su Recipe para asignar un dominio personalizado determinista (p. ej., api.enterprise.com) o exportar la cadena de interpolación nativa de IaC, garantizando que el compilador AOT tenga una referencia conocida para inyectar de forma segura).

La mecánica de implementación (el catálogo como contrato de API) Para implementar esto sin acoplar estrechamente a los Desarrolladores con Ops, Aggrega utiliza el catálogo de la plataforma (Dominio 2) como contrato de API estricto, mediante tres capas de validación distintas:

  1. El esquema de la Feature de credenciales (etiquetado feature.aggrega.ai/kind: secret): Valida SOLO la consulta al vault (path, key). Es totalmente agnóstico respecto a cómo consume los datos el contenedor.
  2. El esquema Component (lista de permitidos spec.inject): Impone la regla Black-Box/White-Box mediante el campo spec.inject. Si spec.inject está presente (p. ej., inject: ["env", "file"]), el desarrollador puede usar self-inject a nivel de componente con esos mecanismos de entrega. Si se omite spec.inject, el compilador prohíbe estructuralmente el self-inject — los componentes Black-Box dependen por completo del valuesMapping de la Recipe para el cableado interno. La compilación lo impone cuando resuelve el Aggregate, rechazando el bloque inject: del componente y nombrando el mecanismo, de forma distinta a la validación de contenido por pilar bajo schema:.
  3. El mapa featuresSchema: Definido en el catálogo del Component, declara explícitamente los slots de credenciales que el Desarrollador debe (o puede) usar. Cada entrada especifica required (por defecto false), la lista de permitidos inject ([] = blackbox, [env, file] = transparente) y description. Como estas claves son estables y están garantizadas por contrato, el ingeniero de Ops puede confiar directamente en ellas para dictar de forma fiable destinos deterministas en su plantilla de Go (p. ej., existingSecret: "{{ .context.rendered_name }}-{{ .locals.secret_target_admin_password }}" en el destino helm), exportando explícitamente el sufijo del nombre mediante .locals — un local no puede leer .context.rendered_name —, de modo que la FeatureRecipe de credenciales posterior une las mismas dos partes y cumple el requisito sin violar el orden de ejecución AOT. Consulta entities/component.md para el diseño completo de featuresSchema.

La regla de ubicación estricta: El mecanismo inject: está disponible en tres ubicaciones del Aggregate del Desarrollador:

  1. Self-inject a nivel de Component: Como hermano directo de values: en una instancia de componente. Inyecta los valores literales propios del componente o sus propias claves provides en la tubería de entrega. Solo se permite si el catálogo del Component declara spec.inject con los mecanismos correspondientes.
  2. Cross-inject a nivel de uses: Dentro de definiciones explícitas de destinos en el bloque uses:. Inyecta las claves provides de un destino de dependencia en la tubería de entrega.
  3. Inject a nivel de Feature/secret: Como hermano de values: al adjuntar funcionalidades y secretos. Inyecta las claves provides resueltas propias del adjunto — la credencial resuelta para un secreto, o los valores proporcionados por una funcionalidad — en la tubería de entrega.

Las tres formas pueblan la misma tubería .context.inject. La Recipe lee una única tubería unificada, sin importar cuántas fuentes hayan contribuido a ella.

El esquema de inject define enumeraciones estándar (env, file, arg) para las herramientas, pero deja abierto additionalProperties, de modo que se puede nombrar un mecanismo personalizado (p. ej., ssm_param para AWS Systems Manager Parameter Store). Un nombre está reservado: all es la vista combinada de todos los mecanismos que una Recipe lee en .context.inject.all, así que un bloque inject que nombra un mecanismo all detiene la compilación en el envoltorio del documento, indicándolo.

Sintaxis de las entradas de inject: Bajo un bloque inject, cada mecanismo de entrega — env, file, arg o uno personalizado — es una lista de entradas, y cada ubicación usa la misma forma de entrada. Es la palabra clave que lleva una entrada, no la ubicación en la que está, lo que dice qué es su cadena, de modo que una entrada se lee igual dondequiera que aparezca. Un mecanismo escrito como mapa en lugar de lista, o una entrada que lleva ambas palabras clave, detiene la compilación en la envoltura del documento del Aggregate, nombrando la ruta en el Aggregate donde la forma es incorrecta.

Palabras clave de las entradas (from: y value:): Cada entrada usa la palabra clave in para el identificador local — un nombre de variable de entorno, una ruta de archivo, un flag de argumento — más exactamente uno de from: (referencia a una clave de provides) o value: (cadena literal). Un from: se resuelve contra los provides del nodo que nombra su ubicación: los propios del componente en component.inject, los del destino en uses[target].inject y los propios del adjunto en features[<name>].inject:

Palabra claveSignificadoPermitido en component.injectPermitido en uses[].injectPermitido en features[<name>].inject
from:Se resuelve contra provides✅ provides del propio nodo✅ provides del nodo de destino✅ provides propios del adjunto
value:Cadena literal (admite plantillas de Go)✅❌ (value: no es válido en uses[].inject; usa inject a nivel de componente para el self-inject)❌ (value: detiene la compilación en el inject de un adjunto; usa inject a nivel de componente para el self-inject)

Ejemplos:

# Component-level self-inject (White-Box custom code)
components:
my-worker:
type: core/python-worker:1.0.0
values:
app_token: "xyz"
inject:
env:
- in: MY_TOKEN
value: "xyz" # Literal value
- in: LOG_LEVEL
value: "debug" # Literal value
- in: CALLBACK_HOST
from: "host" # From own provides (already evaluated)
- in: APP_VERSION
value: '{{"{{"}} .values.app_token }}' # Go template expanding own values
uses:
databases:
my_db:
target: postgres-db
inject:
env:
- in: DB_HOST
from: "host" # Provides key from target
- in: DB_PORT
from: "port" # Provides key from target
- in: DB_URL
from: "dsn" # From target's provides

La plantilla del value: de APP_VERSION comienza con {{"{{"}} en lugar de {{: todo el texto del Aggregate se lee una vez como plantilla, para la interpolación de parámetros, antes de que se ejecute la resolución del self-inject, y .values no existe en ese momento, de modo que el escape devuelve {{ para que la resolución del self-inject lo evalúe. Consulta Texto que contiene sus propias llaves dobles.

Nota específica del Provider (compose). Cuando las aristas uses: se resuelven entre nodos dirigidos a compose, el proveedor compose deriva entradas depends_on de esas aristas. Esas entradas usan siempre la semántica service_started, independientemente del bloque health: de cualquier destino; condicionarlas a la salud del destino no está implementado. Consulta providers/compose.md para las reglas de inferencia completas.

La regla de colisión de claves de inject: Que un desarrollador solicite la misma clave de entrega (p. ej., el mismo nombre de variable de entorno) desde dos fuentes distintas es un error fatal, no una fusión. El compilador detecta la colisión y detiene la compilación:

Fuente AFuente BResultado
component.injectuses[].inject❌ detención fatal — clave de entrega duplicada
uses[target_A].injectuses[target_B].inject❌ detención fatal — clave de entrega duplicada
component.injectfeatures[<name>].inject❌ detención fatal — clave de entrega duplicada
uses[].injectfeatures[<name>].inject❌ detención fatal — clave de entrega duplicada
features[A].injectfeatures[B].inject❌ detención fatal — clave de entrega duplicada
component.inject (la misma clave dos veces)—❌ detención fatal — clave de entrega duplicada
injectMapping de la FeatureRecipe de features[A]injectMapping de la FeatureRecipe de features[B]❌ detención fatal — clave de entrega duplicada entre dos adjuntos
features[A].injectinjectMapping de la FeatureRecipe de features[B]❌ detención fatal — clave de entrega duplicada entre dos adjuntos
component.inject o uses[].injectinjectMapping de la FeatureRecipe✅ Legal — interceptación por diseño: el valor del mapeo sustituye esa entrada

La tabla se aplica igual a cada Feature adjunta, dondequiera que se haya adjuntado — en el componente, en un subsistema o en un límite de la Release, por la expansión de una anotación, o en una conexión. El injectMapping de una FeatureRecipe se renderiza después de que cada bloque inject: haya entregado, de modo que siempre es la posterior de dos reclamaciones: puede reescribir lo que entregó el componente o una de sus conexiones, y puede reescribir lo que entregó el bloque inject: de su propio adjunto, pero una clave que otra Feature adjunta ya entregó detiene la compilación, nombrando ambas.

Una Feature adjunta a un límite de la Release cuya FeatureRecipe se renderiza una sola vez para el límite (executionScope: boundary) llega a los componentes que contiene el límite por la misma vía: su injectMapping se ejecuta una vez para cada uno de ellos, en el contexto de ese componente, y está sujeto a las filas anteriores como cualquier otro mapeo. El puente de compose que reescribe la variable de host de un consumidor para que alcance su destino a través de su gateway es uno de esos mapeos, de modo que otra Feature adjunta que entregó la misma variable detiene la compilación, nombrando ambas.

Para evitar el código repetitivo de plantillas de Go en las Recipes, el compilador proporciona ambos:

  • .context.uses: El mapa enriquecido de aristas topológicas (para lógica compleja, referencias a secretos y seguimiento del origen).
  • .context.inject: Un diccionario prerresuelto y aplanado en el que el compilador ya ha resuelto todas las fuentes de inject (literales de self-inject, referencias a provides de self-inject y referencias a provides entre componentes) en valores de cadena finales, y luego ha aplicado las interceptaciones injectMapping de FeatureRecipe.

El contexto de inyección de doble estado (seguridad frente a nulos vs. pureza de la intención) Al generar configuraciones para los Modificadores (la FeatureRecipe vinculada a cualquier adjunto, de credenciales o de otro tipo), el compilador debe equilibrar la seguridad frente a punteros nulos para las plantillas de Go, el enrutamiento dinámico de red y la preservación de un grafo agnóstico respecto a las capacidades. Para lograrlo, el compilador proporciona a la plantilla un contexto de doble estado:

  • .inject_raw (la intención inmutable): Representa el bloque inject: propio del componente exactamente como el desarrollador lo escribió en el Dominio 1. Es inmutable. Si el desarrollador omitió el bloque, se evalúa como null. Ops lo utiliza específicamente para comprobaciones lógicas (p. ej., {{ if not .inject_raw }} para aplicar comportamientos de respaldo). Como es inmutable, protege las plantillas de Ops de falsos positivos si las funcionalidades de enrutamiento interceptan y modifican la tubería de entrega física.
  • .context.inject (la tubería prehidratada e interceptada): Una struct paralela, generada por el compilador, que representa la realidad física de la entrega. Comienza como un mapa prehidratado (p. ej., que asigna API_HOST a la cadena base del destino "backend-instance"). Fundamentalmente, esta tubería está diseñada para ser interceptada y fusionada en profundidad por las Features (p. ej., el enrutamiento de red) mediante el bloque injectMapping. Para cuando se renderiza la Recipe base, esta tubería contiene las cadenas completamente formateadas y físicamente correctas (p. ej., un nombre de red completo y correcto como "backend-instance.backend-zone.svc.cluster.local"). Su contenido se estructura como env, file, arg (más cualquier mecanismo de entrega personalizado que permitan las listas de permitidos de inject del Component), con un diccionario .all prefusionado que combina todos los mecanismos para una cómoda serialización de toda la tubería.
  • .context.self_inject (Qué valor propio entrega cada nombre): Se lee del mismo bloque inject: a nivel de componente que .inject_raw, con la forma en que .context.uses.<alias>.inject da los nombres de una conexión: por mecanismo, cada nombre que escribió el desarrollador se asigna a la clave propia del componente que entrega su entrada — provides.<key> para una entrada from:, values.<key> para una plantilla value: que lee exactamente uno de los valores propios del componente y nada más, y una cadena vacía para cualquier otra cosa (un literal, dos valores, una lectura de cualquier cosa que no sean los valores). Permite que una Recipe que ejecuta la imagen propia del desarrollador trate sus propios nombres de variable como valores predeterminados — entregando un valor propio bajo su nombre predeterminado solo cuando ninguna entrada se asigna ya a values.<key>, de modo que un desarrollador que renombra un valor conserva todos los demás predeterminados. Esa es la convención del catálogo de la biblioteca estándar, no una regla del compilador; un catálogo empresarial puede entregar los valores propios de sus componentes como prefiera.

Ops utiliza la struct .context.inject exclusivamente para la serialización segura (p. ej., {{ toJson .context.inject.all }}) y la generación del enrutamiento, lo que garantiza que la infraestructura física reciba las coordenadas completamente resueltas mientras la intención original del desarrollador permanece perfectamente intacta en .inject_raw.

Ejemplo de YAML del desarrollador (mapa granular):

uses:
databases:
my-postgres-cluster:
target: db-main
inject:
ssm_param: # Agnostic injection paradigm (AWS Systems Manager)
- in: MY_DB_HOST # Local identifier
from: "host" # Target provides key

El compilador lo resuelve en tiempo de compilación (asignándolo a cadenas estáticas o nombres DNS internos) y pasa los dos objetos a la Recipe:

"context": {
"uses": { ... raw graph ... },
"inject": {
"all": { "MY_DB_HOST": "db-main.internal" },
"ssm_param": { "MY_DB_HOST": "db-main.internal" }
}
}

Configuración con ámbito de conexión (values e infra). Además de entregar los provides de un destino mediante inject, una arista puede llevar su propia configuración — ajustes por conexión que la Recipe consumidora lee de la tubería de topología enriquecida:

  • .context.uses.<alias>.values — escrito por el desarrollador, declarado en la entrada uses detallada del Aggregate, validado contra el valueSchema del socket.
  • .context.uses.<alias>.infra — escrito por el operador, declarado en la Release, validado contra el infraSchema del socket.

El socket (usesSchema[<socket>]) es el contrato del Arquitecto sobre qué conexiones son posibles y qué configuración pueden llevar; values e infra reparten esa configuración por dominio de autoría, reflejando la división values/infra en los componentes. Así, una arista tiene dos autores: el desarrollador conecta la topología y la ajusta con values en el Aggregate, mientras que el operador establece infra por conexión en la Release, dentro de los sockets que declaró el Arquitecto. La Release también puede conectar una arista en un socket declarado pero sin vincular hacia un componente existente; no puede redirigir una arista declarada por el desarrollador — consulta entities/release.md §«Per-edge connection configuration (Configuración de conexión por arista)».

La configuración por arista tiene ámbito del consumidor: aparece solo en el contexto del nodo que escribió la arista (el origen de la conexión), nunca en el contexto del destino. La salida renderizada propia de un destino es, por tanto, invariante respecto a los consumidores que se conectan a él. Una Feature adjunta al destino es el único lugar donde las conexiones son visibles: su FeatureRecipe lee qué componentes usan el destino en .context.used_by — de cada uno, su identidad, su socket, sus provides publicados, el namespace y el límite en que está colocado y, para una FeatureRecipe que declara que los lee, los hechos de renderizado que informaron sus proveedores — nunca los values ni la infra propios de la conexión. Una Feature adjunta al consumidor lee, de la misma manera, lo que informaron los renderizados de cada uno de sus destinos, en la entrada de esa conexión en .context.uses.<alias>.render_facts, donde su FeatureRecipe declara que los lee.

Adjuntos de conexión (features). Una conexión también puede llevar adjuntos propios — por ejemplo, una credencial que el consumidor presenta al componente al que llega esta conexión — bajo features: en su entrada, indexados por un slot que el socket declara en su featuresSchema. Los mismos dos autores se los reparten: el desarrollador adjunta en la entrada de conexión del Aggregate con type y values, y el operador dimensiona ese adjunto con infra, o adjunta uno propio con type e infra, en la entrada de la Release. Un adjunto en una conexión no lleva ningún bloque inject propio, por lo que no aparece en la regla de ubicación anterior: no es uno de los lugares donde un desarrollador dicta la entrega.

Cada uno se convierte en un adjunto del componente consumidor llamado <alias>.<slot>, de modo que tiene ámbito del consumidor exactamente como la configuración por arista: su FeatureRecipe se renderiza del lado del consumidor, y la salida del destino no cambia con él. Se mantiene fuera de los .features de la Recipe consumidora, que contiene solo los adjuntos que declara el bloque propio del componente; la Recipe lo lee en cambio bajo su conexión, en .context.uses.<alias>.features.<slot>. Una conexión que traza un adjunto de Feature no lleva adjuntos. Consulta entities/aggregate.md §«A connection’s own attachments (Los adjuntos propios de una conexión)» y entities/component.md §«Topology Sockets (Sockets de topología)».

A. Variables de entorno (env) y resolución dinámica del destino El mecanismo de entrega estándar para las aplicaciones nativas de la nube modernas. Para las aristas topológicas explícitas (p. ej., un agente que se comunica con una base de datos), Aggrega usa .context.uses para inyectar la asignación de variables de entorno.

  • Caso de uso: Recibir nombres DNS internos deterministas, cadenas de interpolación de Infrastructure-as-Code (p. ej., ${module.db.endpoint}) o punteros estáticos de Vault. El compilador conecta estas referencias estáticas en AOT para que la infraestructura de tiempo de ejecución o el controlador de GitOps puedan resolver los valores reales.

B. Montajes de archivos (file) Muchos frameworks de IA empresariales esperan que exista un config.json estructurado o un certificado .pem en una ruta específica del disco, en lugar de depender de variables de entorno.

  • Caso de uso: Inyectar configuraciones JSON complejas o satisfacer SDK heredados que leen del disco.

  • Intención del desarrollador:

    features:
    openai_key:
    type: core/aws-secrets-manager
    values:
    path: /prod/ai/openai
    key: "api_token"
    inject:
    file:
    - in: "/etc/secrets/openai.json" # Local path
    from: "api_token" # The attachment's provides key
  • Realidad de Ops: La Recipe de Ops genera dinámicamente los Volume, VolumeMount y ExternalSecret de Kubernetes necesarios para extraer de forma segura los datos del almacén de secretos y montarlos en /etc/secrets/openai.json.

C. Argumentos de línea de comandos (arg) Los binarios precompilados (como los nodos worker en Rust o Go) a menudo omiten por completo las variables de entorno y esperan que los valores se pasen como flags de tiempo de ejecución en su comando de ejecución.

  • Caso de uso: Añadir realidades físicas al comando de arranque del contenedor.

  • Intención del desarrollador:

    features:
    public-ingress:
    type: core/external-ingress
    inject:
    arg:
    - in: "--callback-url=" # Local flag
    from: "hostname" # The attachment's provides key
  • Realidad de Ops: El nombre de host es el nombre que el entorno da al componente, así que el operador lo escribe, api.enterprise.com, en la infra de este adjunto en la entrada de la Release para el componente. El plugin Wasm de la Feature recibe la URL pública resuelta a través del Injection Contract y emite un JSONPatch para añadir dinámicamente elementos al array args de Kubernetes: ["/app/binary", "--callback-url=https://api.enterprise.com"], omitiendo por completo la Recipe base del Component.