Los hechos de vinculación que lee una política de gobernanza
Un plugin de gobernanza vinculado en el rol ir-verdict recibe el grafo completo de la compilación, y cada vinculación de Feature de la compilación llega con él. Cada vinculación lleva un conjunto fijo de hechos sobre sí misma: qué Feature nombra, qué ranura llena, en qué conexión se escribió, cuando se escribió en una, qué FeatureRecipe la realiza, qué declaró sobre ella el autor del catálogo, qué escribió en ella un autor, y si maneja material que alguien declaró sensible. Una cosa no llega tal como está escrita: un valor que un autor declaró sensible llega retenido — consulta Los valores declarados sensibles llegan retenidos.
Esta página enumera esos hechos y dice qué afirma y qué no afirma cada uno. Para el socket en sí — los cuatro roles, las severidades del veredicto, el canal de entrada del operador y los dos motores de políticas que se incluyen dentro del compilador — consulta policy-socket.md. Para la tabla campo por campo con tipos y obligatoriedad, consulta la referencia del esquema del grafo generada; esta página enseña a leer los hechos, y aquella página es el contrato.
Dónde se encuentran las vinculaciones en la carga útil
Las vinculaciones cuelgan del grafo de la compilación bajo feature_values_mapping, con el id del nodo como clave y después el nombre de instancia que el autor dio a cada vinculación:
input.graph.spec.feature_values_mapping[<node id>][<attachment name>]El nombre de la vinculación es estructural, no decorativo. Es la clave con la que un autor llena una ranura, así que también es lo que el compilador empareja con las ranuras declaradas del Component anfitrión.
Una vinculación escrita en una de las conexiones de un componente — bajo features: en una entrada uses, en el Aggregate o en la Release — es una de las vinculaciones del componente consumidor, así que se encuentra en el mismo contenedor, en el nodo del componente consumidor. Su clave es el nombre que le da el compilador, el alias de la conexión y la ranura unidos por un punto: gpt.credential para la ranura credential de la conexión escrita bajo el alias gpt. El punto nunca aparece en un nombre que escribe un autor, así que esa clave nunca es igual al nombre de una de las vinculaciones propias del nodo. Sin embargo, una política no lee la conexión a partir de la clave: la entrada la lleva como dato, en connection más abajo.
package security
import rego.v1
deny contains msg if { some node_id, attachments in input.graph.spec.feature_values_mapping some name, attachment in attachments attachment.binding == "free" msg := sprintf("%v carries attachment %v, which fills no declared slot.", [node_id, name])}Solo ir-verdict ve estos hechos. Una política render-verdict recibe los artefactos renderizados y ningún grafo; una política label-transform recibe una proyección de las etiquetas y los valores de los nodos, con sus valores declarados sensibles retenidos como aquí, que no lleva ninguna vinculación; una política annotation-transform recibe los componentes que puede anotar. Una regla que lee hechos de vinculación corresponde a ir-verdict, y moverla a otro rol produce una regla que nunca se activa en lugar de un error, porque una ruta que no existe simplemente está indefinida.
Un solo contenedor, todas las familias de vinculaciones
Cada vinculación de un nodo se encuentra en el mismo contenedor, sea lo que sea lo que produzca su Feature — una Feature operativa, una Feature de credenciales, una Feature de identidad. Ninguna familia recibe una proyección más estrecha que otra, así que una política que recorre el contenedor las ve todas y nunca necesita saber qué familia está mirando antes de poder leer un hecho.
Identidad: type y resolved_version
type es la URI de la Feature del catálogo que nombra la vinculación. resolved_version es la versión exacta en la que se fijó la resolución para esta compilación. Ambos están siempre presentes.
Metadatos del catálogo, trasladados literalmente: labels y catalog_annotations
labels son los metadata.labels propios de la entidad Feature vinculada. catalog_annotations son los metadata.annotations propios de esa entidad. Ambos se llevan en el orden en que los declara la entidad del catálogo, y ninguno se filtra, se normaliza ni pierde su prefijo — una clave en el namespace propio del autor del catálogo llega exactamente tal como está escrita, y el compilador no lee ninguna de ellas.
Ese traslado literal es lo que permite que una política tome como clave una etiqueta cuya existencia el compilador no tiene motivo para conocer. Un autor de catálogo que marca las Features de credenciales con una etiqueta de su propia invención puede escribir una regla directamente sobre esa etiqueta.
Cada uno está ausente de la vinculación cuando la Feature no declara ninguno, y cuando su type no se resuelve en ninguna entidad del catálogo.
catalog_annotations describe la entidad que nombra la vinculación. Es una cuestión distinta de annotation_key y annotation_source más abajo, que describen cómo llegó a existir la vinculación. Una vinculación escrita en un bloque features: lleva anotaciones del catálogo sin llevar ninguno de los otros dos.
Qué ranura llena la vinculación: binding
binding tiene tres respuestas, y la tercera no es una variante de la segunda:
| Valor | Significado |
|---|---|
| un nombre de ranura | La vinculación llena la ranura de vinculación declarada con ese nombre. |
free | La vinculación no llena ninguna ranura declarada. Es un hallazgo positivo: el conjunto de ranuras se resolvió y ninguna ranura declarada lleva este nombre. |
| ausente | No se pudo resolver el conjunto de ranuras declaradas del Component anfitrión, así que se desconoce qué ranura se llena. |
De qué conjunto de ranuras declaradas proviene el nombre depende de dónde se escribió la vinculación. Una vinculación del bloque propio del nodo llena una ranura que el Component anfitrión declara en su propio featuresSchema. Una vinculación escrita en una conexión — una que lleva connection más abajo — llena una ranura que declara el socket de la conexión, en el featuresSchema de ese socket en el Component anfitrión. Así, el mismo valor, credential, nombra una ranura del Component en una vinculación y una ranura de un socket en otra, y connection es lo que las distingue.
El emparejamiento es por nombre — una vinculación llena una ranura cuando la Feature se vincula bajo el nombre de la ranura, en el bloque del componente o en la conexión — así que el valor es una clave exacta del conjunto de ranuras declaradas. No se lee nada de la clave de la vinculación: la vinculación de una conexión tiene la clave gpt.credential e informa de credential. Se lleva el nombre de la ranura en lugar de un simple indicador porque qué ranura se llenó es la mitad más útil de la respuesta.
Una vinculación escrita en una conexión nunca informa de free. Las ranuras de un socket son los únicos nombres que puede llevar una conexión a través de él, y una conexión que lleva cualquier otro nombre se rechaza al cargarse la compilación, así que toda vinculación de ese tipo en un grafo que llega a una política llena una ranura declarada.
Una política que trata un binding ausente como free informará de una incógnita como hallazgo. Comprueba free explícitamente.
En qué conexión se escribió la vinculación: connection
connection está presente en cada vinculación escrita en una de las conexiones del nodo, y ausente en cada vinculación del bloque propio del nodo. Lleva dos campos, las coordenadas de esa conexión en el nodo:
| Campo | Significado |
|---|---|
socket | El socket a través del cual está conectada la conexión. |
alias | El alias bajo el que está escrita la conexión. |
El par nombra una de las aristas del grafo: la arista cuyo source es el nodo que lleva la vinculación y cuyos socket y alias son estos. El target de esa arista es el componente al que se presenta la vinculación. Así, una política une una vinculación con lo que alcanza — algo que ningún hecho de la vinculación por sí sola puede decir, porque la vinculación se encuentra en el nodo consumidor:
package security
import rego.v1
deny contains msg if { some node_id, attachments in input.graph.spec.feature_values_mapping some name, attachment in attachments attachment.labels["feature.aggrega.ai/kind"] == "secret" some edge in input.graph.spec.edges edge.source == node_id edge.socket == attachment.connection.socket edge.alias == attachment.connection.alias input.graph.spec.nodes[edge.target].labels["example.com/trust-zone"] == "external" msg := sprintf("%v presents the credential %v to %v, outside the trust zone.", [node_id, name, edge.target])}Qué afirma connection, y qué no afirma:
- Registra dónde escribió el autor la vinculación. Se rellena a partir de la conexión en la que se escribió la vinculación, nunca se extrae de la clave de la vinculación, así que contiene el socket — que la clave no lleva — además del alias.
- No lleva la ranura. Qué ranura del socket llena la vinculación es
binding, que se lee igual que para cualquier vinculación; la ranura se informa una sola vez, allí. - No describe el destino. El destino, sus etiquetas y quién conectó la arista — el desarrollador, la Release o una Feature — son hechos de la arista y del nodo de destino, que se leen allí después de la unión.
- Una conexión que traza una Feature no lleva vinculaciones, así que ninguna vinculación lleva una
connectionque nombre una arista así. Una credencial que necesita la propia conexión de una Feature es una vinculación que llena una ranura que declara la Feature, y no lleva ningunaconnection. - Ausente significa el bloque propio del nodo. Una vinculación sin
connectionse escribió en losfeatures:propios del componente (o le llegó desde un ámbito más amplio o mediante la expansión guiada por anotaciones). No es un hallazgo de que la vinculación no se presente a ningún otro componente: a qué llega la credencial propia de un componente lo decide cómo está conectada su entrega, algo que este campo no describe.
Más allá de decidir de qué conjunto de ranuras declaradas se leen binding y la mitad de ranura de sensitive, connection no cambia nada de la vinculación: su FeatureRecipe, su contrato provides, el resto de sus hechos y su lugar en el contenedor son los de cualquier vinculación que lleve el nodo.
Qué FeatureRecipe realiza la vinculación: realization
realization nombra la FeatureRecipe que el Manifest de la Release enlaza con la vinculación, como <name>:<version>. El Manifest enlaza por el nombre propio de la vinculación donde su nivel name mapea ese nombre — para una vinculación escrita en una conexión, su nombre cualificado, gpt.credential más arriba — y, en caso contrario, por el tipo de Feature que nombra la vinculación. La FeatureRecipe nombrada es aquella con la que una compilación de los mismos documentos renderiza la vinculación: el grafo registra el enlace antes de que se renderice nada, y el renderizado enlaza la vinculación de la misma manera.
package security
import rego.v1
approved_realizations := {"approved-credential:1.0.0"}
deny contains msg if { some node_id, attachments in input.graph.spec.feature_values_mapping some name, attachment in attachments attachment.labels["feature.aggrega.ai/kind"] == "secret" realization := attachment.realization not realization in approved_realizations msg := sprintf("%v realizes the credential %v with %v, which is not an approved FeatureRecipe.", [node_id, name, realization])}Qué afirma realization, y qué no afirma:
- Es el mismo par en todas partes donde aparece.
aggrega inspectlo imprime como la realización de la vinculación, y donde un destino estampa la procedencia en lo que renderiza, los documentos que renderiza esa FeatureRecipe lo llevan como su valor deaggrega.ai/recipe-uri, así que una política une una vinculación con lo que renderiza sin traducir entre formas. - Nombra la FeatureRecipe por nombre y versión, no por capacidad. Dos capacidades pueden publicar cada una una FeatureRecipe con un mismo nombre y una misma versión. Cuál de ellas queda enlazada lo establece el mapeo del Manifest, que nombra la capacidad dondequiera que el nombre por sí solo sería ambiguo; este campo no lo repite.
- Las vinculaciones propias de un límite de una Release también lo llevan, bajo
boundary_features, y se leen de la misma manera. Una vinculación a nivel de límite también llega a cada componente que contiene el límite, y allí lleva la misma realización. - Ausente significa enlazada a nada. Una vinculación que el Manifest no enlaza con ninguna FeatureRecipe que contenga el catálogo no lleva ninguna
realization. Una compilación de una composición así se detiene antes de renderizar, nombrando la vinculación sin mapear — pero a una política en este rol se le pregunta antes de esa detención, así que puede encontrarse con una vinculación que no lleva ninguna. La regla de arriba deja pasar una vinculación así, porque su cuerpo enlaza primerorealization; una regla que quiera informar de ella comprueba explícitamente la clave que falta.
Cómo llegó a existir la vinculación: origin y sus dos acompañantes
origin distingue una vinculación que tecleó un desarrollador de una que produjo la expansión guiada por anotaciones:
| Valor | Significado |
|---|---|
explicit | Escrita en un bloque features:. |
annotation | Producida por la expansión guiada por anotaciones. |
mixed | Las hojas de valores o de infra de la vinculación llevan una mezcla de ambas; el detalle por hoja está en los mapas de procedencia. |
annotation_key nombra la anotación que desencadenó una vinculación sintética, y annotation_source localiza su declaración como <release-file-path>:<dotted-yaml-key-path>. Ambos están ausentes cuando origin es explicit.
Las cargas útiles escritas por el autor: values, infra e inject
values es la configuración operativa de la vinculación — el dominio del desarrollador. infra es su dimensionamiento físico por instancia — el del operador. inject es el enrutamiento agnóstico de la inyección, que mapea las claves de entrega a las claves provides de las que se llenan, con el mecanismo de entrega como primera clave.
Lo que lleva el values de una vinculación de credenciales es elección del autor, y el compilador lleva lo que se haya escrito sin resolver ninguna de las dos: una credencial por referencia lleva un puntero a un almacén de secretos, y una por valor lleva el propio material. Sea cual sea, una hoja que la Feature vinculada declara sensible llega a una política retenida, como describe la sección siguiente; una hoja que deja sin declarar, como un localizador publicado, llega tal como está escrita.
Los valores declarados sensibles llegan retenidos
Cada hoja que el grafo marca como declarada sensible llega a este socket como un marcador de retención en lugar de como el valor que escribió un autor. El marcador es un objeto de clave única que lleva el motivo por el que falta el valor:
{ "aggrega_withheld": "declared" }declared significa que una declaración cubre la hoja. Una carga útil que no se pudo leer en absoluto se retiene entera, con el motivo unreadable, porque no se pudo juzgar ninguna hoja de su interior.
La retención sigue los marcados propios del grafo, así que alcanza exactamente las hojas que estos nombran, dondequiera que estén:
- los
valuesy elinfrade cada vinculación, sea cual sea el ámbito que escribió la vinculación — el bloque propio del componente, un subsistema, un límite o la Release, una expansión guiada por anotaciones — y tanto si se escribió en el bloque propio del nodo como en una de sus conexiones, según las hojas que nombra susensitive_payload_leaves; - el
infrade una vinculación a nivel de límite, bajoboundary_features, según su propio marcado; - los
valuesy elinfrapropios de un nodo, bajovalues_mappingeinfra_mapping, según elsensitive_payload_leavespropio del nodo; - los
valuesy elinfrapropios de una conexión, en la arista y en la entradausesdel nodo consumidor, según elsensitive_payload_leavesde la arista, que nombra las hojas que el socket del componente consumidor declara sensibles.
Aquello sobre lo que razona una política queda intacto. El tipo, la versión resuelta, las etiquetas, las anotaciones de catálogo, binding, connection, realization, origin y sus mapas de procedencia, los tres hechos de sensibilidad y cada hoja que ninguna declaración marca llegan tal como se escribieron. La clave de una hoja retenida también se conserva, así que una política sigue viendo qué hojas lleva una carga útil y cuáles de ellas llevan material declarado — solo falta el valor. Una regla sobre por dónde viaja el material declarado sensible, y por qué ruta, es por tanto plenamente expresable; una regla sobre el contenido del material no lo es, por diseño.
El bloque uses escrito por el autor de un nodo, llevado en el nodo junto a sus aristas, conserva de cada vinculación escrita en una conexión solo su type y su description. Los valores de la vinculación se llevan una sola vez, en la propia vinculación, donde la retención los alcanza.
Una política que quiere distinguir una hoja retenida de una escrita por el autor comprueba la clave del marcador:
package security
import rego.v1
audit contains msg if { some node_id, attachments in input.graph.spec.feature_values_mapping some name, attachment in attachments some key, value in attachment.values is_object(value) value.aggrega_withheld msg := sprintf("%v/%v writes a declared-sensitive value at values.%v.", [node_id, name, key])}Es la misma retención que aplica --ir-graph cuando un comando imprime el grafo y que aplica aggrega/irGraph del daemon cuando responde a un cliente, así que una política y una persona que lee el grafo ven retenidas las mismas hojas. Esas superficies devuelven los valores a una persona que los pide con --unredacted; la carga útil que recibe una política no ofrece tal solicitud, y en ella los valores declarados propios de un nodo se retienen en las mismas condiciones que los de una vinculación. Se aplica a la carga útil que recibe una política y a nada más: el grafo a partir del cual renderiza la compilación queda intacto, así que la retención no cambia ningún byte renderizado. No se retiene nada de lo que recibe una política render-verdict, porque los artefactos renderizados son lo que juzga ese rol.
De dónde procede cada hoja: values_provenance e infra_provenance
Cada uno está indexado por la ruta con puntos de la hoja dentro de su pilar, y cada entrada registra el origin de esa hoja — la misma distinción explicit / annotation, aplicada hoja por hoja. Una hoja aportada por una anotación lleva además la superficie de autoría en la que se declaró, la clave de anotación que la aportó y la ubicación en el código fuente de esa declaración. Cuando una hoja explícita sobrescribió una aportada por una anotación, la entrada lleva también la contribución suprimida que reemplazó, así que una política puede ver lo que se sobrescribió y no solo lo que prevaleció.
Las tres unidades de sensibilidad
La carga útil lleva tres hechos de sensibilidad, y se sitúan en tres unidades distintas: una vinculación entera, una clave de entrega, una hoja de la carga útil.
Cada uno se calcula a partir de sus propias entradas. Ninguno se deriva de otro, y en particular la respuesta por vinculación nunca se propaga hacia las unidades más estrechas. Confundir dos cualesquiera de ellos produce una política equivocada en una dirección que falla en silencio, así que vale la pena leer los tres por separado antes de escribir una regla sobre cualquiera de ellos.
Cada uno de ellos se deriva de lo que un autor declaró — sensitive: true en una hoja del esquema de una Feature, o sensitive: true en una ranura de vinculación que declara un Component, para sus propias vinculaciones o en uno de sus sockets. No se inspecciona el contenido de ningún valor, y no se extrae ningún significado del nombre de un campo.
sensitive — una respuesta para toda la vinculación
Verdadero cuando la Feature vinculada declara una hoja sensible en sus values, infra o provides, o cuando la ranura que llena la vinculación declara que lo que sea que la enlace maneja material secreto — la ranura de vinculación del mismo nombre del Component anfitrión o, para una vinculación que lleva connection, la ranura de ese nombre que declara el socket de la conexión. Sin establecer cuando ninguna de las dos declaraciones está presente.
Esto responde a qué es la entidad, así que deliberadamente no varía con lo que escribió un autor concreto. Lee las declaraciones de la Feature en lugar del subconjunto de hojas sensibles que esta vinculación llegó a llenar, porque un campo que fuera sensible en una Release y no en otra sería inutilizable para una política que razona sobre la entidad de catálogo.
Las dos mitades son independientes, y cada una se sostiene por sí sola. Una Feature que no declara ninguna hoja sensible sigue enlazando una ranura sensible como vinculación sensible, porque la ranura así lo dijo. Un relleno que declara una hoja sensible es una vinculación sensible aunque la ranura no hiciera tal declaración, e incluso cuando es una vinculación libre que no enlaza ninguna ranura.
sensitive_inject — una respuesta por clave de entrega
El subconjunto de inject cuya clave provides referenciada declara sensible la Feature vinculada, llevado en la forma propia de inject: mecanismo, luego clave de entrega, con la clave provides referenciada como valor.
Una clave de entrega que se llena a partir de una clave provides que la Feature marcó como sensible aparece aquí; una que se llena a partir de una clave no marcada no, ni siquiera en la misma vinculación y con el mismo mecanismo. Ausente cuando la vinculación no declara ningún mecanismo de entrega, o no referencia ninguna clave provides sensible.
sensitive_payload_leaves — una respuesta por hoja de la carga útil
Las hojas que lleva la carga útil de esta vinculación cuya ruta declara sensible la Feature vinculada, cada una como la ruta con puntos, prefijada por el pilar, que ocupa el dato: values.<path> o infra.<path>.
La carga útil que se lee aquí es la que la vinculación acaba llevando, no el bloque que escribió un autor. Una hoja que está en un valor que el esquema de la Feature declara como default se nombra igual que una en la que un autor escribió ese valor: un valor predeterminado llenado es un dato que lleva la carga útil, y un marcado leído solo del bloque escrito lo dejaría sin nombrar.
Una hoja aparece donde una ruta que el esquema de la Feature declara sensible la cubre — la declaración nombra esa hoja, o nombra un objeto que la contiene. La coincidencia se evalúa segmento a segmento sobre la ruta con puntos, así que una declaración en db cubre db.password y no alcanza una hoja hermana llamada dbPassword. No se extrae nada del propio texto de la ruta y no se inspecciona ningún valor — si el autor escribió el material en sí en una hoja marcada, o un puntero a él, no es algo que se pueda saber aquí y no es lo que afirma el marcado.
La comparación se hace sobre la carga útil aplanada en sus hojas, no sobre las claves de primer nivel del pilar, así que una hoja anidada dentro de un mapa anidado se compara como cualquier otra.
Las hojas llegan en el orden en que las contiene la carga útil, las del pilar values antes que las del pilar infra — el mismo orden que llevan las propias cargas útiles, que es lo que mantiene los datos transmitidos idénticos byte a byte entre ejecuciones con una entrada idéntica.
Esta unidad responde a dónde puso datos esta vinculación, lo que varía necesariamente según la Release. Por eso se cruza con lo que se escribió mientras que sensitive no: los dos son respuestas a preguntas distintas, y aplicar la regla de uno al campo del otro lo rompería.
Leer los tres juntos
Un autor que vincula una Feature de credenciales que declara sensibles su hoja de values literalPassword y su clave de provides password, llenando una ranura credentials declarada, y que escribe en línea una contraseña literal:
{ "type": "example/db-credential", "resolved_version": "1.0.0", "binding": "credentials", "values": { "secretName": "db-creds", "literalPassword": { "aggrega_withheld": "declared" } }, "inject": { "env": { "DATABASE_PASSWORD": "password" } }, "sensitive": true, "sensitive_inject": { "env": { "DATABASE_PASSWORD": "password" } }, "sensitive_payload_leaves": ["values.literalPassword"]}Tres preguntas distintas, tres respuestas distintas. La vinculación maneja, de algún modo, material declarado sensible (sensitive). La clave de entorno DATABASE_PASSWORD es una de las que lo llevan (sensitive_inject). Y la carga útil de esta vinculación lleva un valor concretamente en values.literalPassword (sensitive_payload_leaves) — mientras que values.secretName, un localizador que la Feature deja deliberadamente sin marcar, está ausente de esa lista aunque la carga útil también lo lleva. La contraseña que escribió el autor llega retenida, mientras que el localizador a su lado llega tal como se escribió: el marcado le dice a una política que hay un valor ahí, y el valor en sí nunca la alcanza.
Una regla que deniega un secreto literal en un artefacto renderizado necesita el tercero. Una regla que exige que cada vinculación que maneja credenciales lleve una etiqueta de propiedad necesita el primero. Sustituir uno por otro cambia qué compilaciones se detienen.
La ausencia no es un permiso
Una hoja solo se lista donde una declaración la cubre. Así que un sensitive_payload_leaves ausente indica que esta vinculación no nombra ninguna hoja que su Feature declare sensible — nunca que la carga útil no sea sensible. Tampoco distingue una vinculación que no tiene ninguna hoja así que nombrar de un productor que no informa de este eje en absoluto: esos dos siguen siendo indistinguibles, y quien lee una clave ausente aprende eso y nada más.
Un guest que lee una lista de hojas ausente como permiso para mostrar o emitir un valor en claro ha leído el marcado al revés.
La clave se omite por completo de los datos transmitidos cuando estaría vacía, así que una vinculación cuya Feature y cuya ranura no declaran nada lleva exactamente los bytes que llevaría si el marcado no existiera. Esa omisión es lo que hace fácil la lectura errónea, y es por eso que vale la pena enunciar la dirección con claridad.
El caso más claro es una vinculación que es sensible y no lista ninguna hoja. Toma la vinculación anterior y cambia dos cosas — el autor escribe solo el localizador, dejando sin llenar la hoja declarada sensible, y llena la clave de entorno a partir de la clave de provides name no marcada de la Feature en lugar de password:
{ "type": "example/db-credential", "resolved_version": "1.0.0", "binding": "credentials", "values": { "secretName": "db-creds" }, "inject": { "env": { "DATABASE_PASSWORD": "name" } }, "sensitive": true}sensitive sigue siendo verdadero — las declaraciones de la Feature no cambiaron — mientras que las dos unidades más estrechas han desaparecido. La vinculación sigue manejando material secreto; simplemente no lo hace a través de una hoja o una clave de entrega que lleve esta vinculación. Una política basada en el valor agregado deniega esta compilación, y una política basada en el marcado por hoja la deja pasar. Ambas son reglas defendibles, y cuál quiere una política es una decisión que el autor de la política toma deliberadamente.
La misma asimetría se da en el otro sentido para sensitive_inject: una vinculación puede escribir una hoja sensible sin encaminar nada sensible a través de una clave de entrega, o encaminar una clave provides sensible sin escribir ningún valor.
Lo que una declaración de sensibilidad no hace
El marcado anota; no es un control. Declarar sensible una hoja o una ranura no cifra nada, no valida ni rechaza un valor y no impone un mecanismo de entrega. Ningún resultado de compilación cambia porque haya una declaración presente.
En la mayoría de los destinos tampoco cambia ningún byte renderizado: un valor declarado sensible que un autor proporcionó en línea se renderiza exactamente igual que uno no declarado. Terraform es la excepción entre los destinos de la biblioteca estándar, porque cuenta con una primitiva nativa de sensibilidad por valor sobre la que puede recaer la declaración — consulta providers/terraform.md «Entradas de módulo declaradas sensibles». Un destino sin una noción propia de sensibilidad no tiene nada que una declaración pueda cambiar.
Lo que las declaraciones hacen en todas partes es hacer legible el hecho — para la propia salida de depuración del compilador, y para una política en este socket que decide qué hacer al respecto. Convertir un marcado en un resultado de compilación es tarea de la política, y para eso existe este socket. Y a una política se le informa del material declarado sensible sin entregárselo: el marcado llega, el valor llega retenido.
Referencias cruzadas
policy-socket.md— el socket de gobernanza: los cuatro roles, las severidades del veredicto, el canal de entrada del operador, los motores de políticas que se distribuyen dentro del compilador y la vinculación de un plugin a un espacio de trabajo.plugin-contract.md— la ubicación del socket en el pipeline y sus formas de transmisión tipadas.- referencia del esquema del grafo — el contrato campo por campo del grafo de compilación, incluidos todos los campos de una vinculación.
entities/component.md«Ranuras de vinculación» — declarar una ranura, y declarar sensible una ranura; y elfeaturesSchemaque un socket declara para las conexiones que pasan por él.entities/aggregate.md«Las vinculaciones propias de una conexión» — escribir una vinculación en una conexión, y el nombre que recibe.vocabulary/compact-form-authoring.md«Declarar sensible una hoja» — la palabra clavesensitive:y el límite de lo que consigue declararla.vocabulary/labels-and-annotations.md— las superficies de etiquetas y anotaciones que lee una política.