Te doy la bienvenida a nuestra página, ahora encontrarás la respuesta a lo que estás buscando.
Solución:
La respuesta aquí depende de algunas preguntas diferentes:
- ¿Es este archivo un static parte de su configuración, registrada en el control de versiones junto con su
.tfarchivos o se genera dinámicamente como parte del proceso de solicitud? - ¿Desea utilizar el contenido del archivo literalmente o necesita sustituir valores en él desde otra parte de la configuración de Terraform?
Estas dos preguntas forman una matriz de cuatro respuestas diferentes:
| Literal Content Include Values from Elsewhere
-------------|----------------------------------------------------------
Static File | file(...) function templatefile(...) function
Dynamic File | local_file data source template_file data source
Describiré cada una de estas cuatro opciones con más detalle a continuación.
Un tema común en todos estos ejemplos serán las referencias a path.module, que evalúa la ruta desde la que se carga el módulo actual. Otra forma de pensar en eso es que es el directorio que contiene el actual .tf expediente. Acceder a archivos en otros directorios es permitido, pero en la mayoría de los casos es apropiado mantener las cosas autocontenidas en su módulo manteniendo juntos los archivos de datos y los archivos de configuración.
Las cadenas de Terraform son secuencias de caracteres Unicode, por lo que Terraform solo puede leer archivos que contengan texto codificado en UTF-8 válido. Para JSON eso no es un problema, pero vale la pena tenerlo en cuenta para otros formatos de archivo que pueden no estar codificados convencionalmente en UTF-8.
los file función
los file La función lee el contenido literal de un archivo del disco como parte de la evaluación inicial de la configuración. El contenido del archivo se trata como si fuera un literal. string valor para fines de validación, por lo que el archivo debe existen en el disco (y por lo general, en su control de versiones) como un static parte de su configuración, en lugar de generarse dinámicamente durante terraform apply.
resource "aws_cloudwatch_event_target" "data"
rule = aws_cloudwatch_event_rule.scheduler.name
target_id = "finance_producer_cloudwatch"
arn = aws_lambda_function.finance_data_producer.arn
input = file("$path.module/input.json")
Ésta es la opción más común y sencilla. Si el file La función es suficiente para sus necesidades, entonces es la mejor opción para usar como opción predeterminada.
los templatefile función
los templatefile función es similar a la file función, pero en lugar de simplemente devolver el contenido del archivo literalmente, en su lugar analiza el contenido del archivo como un string template y luego lo evalúa usando un conjunto de variables locales dadas en su segundo argumento. Esto es útil si necesita pasar algunos datos de otro lugar en la configuración de Terraform, como en este ejemplo:
resource "aws_cloudwatch_event_target" "data"
rule = aws_cloudwatch_event_rule.scheduler.name
target_id = "finance_producer_cloudwatch"
arn = aws_lambda_function.finance_data_producer.arn
input = templatefile("$path.module/input.json.tmpl",
instance_id = aws_instance.example.id
)
En input.json.tmpl puede usar la sintaxis de la plantilla Terraform para sustituir ese valor de variable:
"instance_id":$jsonencode(instance_id)
En casos como este donde todo resultado es JSON, sugeriría generar todo el resultado usando jsonencode, desde entonces, puede dejar que Terraform se preocupe por el escape de JSON, etc. y simplemente escribir la estructura de datos en la sintaxis del objeto de Terraform:
$jsonencode(
instance_id = instance_id
)
Al igual que con file, porque templatefile es una función que se evalúa durante la decodificación inicial de la configuración y su resultado se valida como un valor literal. Por lo tanto, el archivo de plantilla también debe ser un static archivo que se distribuye como parte de la configuración, en lugar de un archivo generado dinámicamente.
los local_file fuente de datos
Las fuentes de datos son tipos de recursos especiales que leen un objeto existente o calculan un resultado, en lugar de crear y administrar un nuevo objeto. Debido a que son recursos, pueden participar en el gráfico de dependencia y, por lo tanto, pueden hacer uso de objetos (incluidos archivos locales) que son creados por otros recursos en la misma configuración de Terraform durante terraform apply.
los local_file la fuente de datos pertenece al local proveedor y es esencialmente la fuente de datos equivalente a la file función.
En el siguiente ejemplo, estoy usando var.input_file como marcador de posición para cualquier referencia a una ruta de archivo creada por algún otro recurso en la misma configuración. En un ejemplo real, lo más probable es que sea una referencia directa a un attribute de un recurso.
data "local_file" "input"
filename = var.input_file
resource "aws_cloudwatch_event_target" "data"
rule = aws_cloudwatch_event_rule.scheduler.name
target_id = "finance_producer_cloudwatch"
arn = aws_lambda_function.finance_data_producer.arn
input = data.local_file.input.content
los template_file fuente de datos
los template_file fuente de datos es la fuente de datos equivalente a la templatefile función. Es similar en uso a local_file aunque en este caso rellenamos la propia plantilla leyéndola como un static archivo, utilizando el file función o local_file como se describe arriba dependiendo de si la plantilla está en un static archivo o uno generado dinámicamente, aunque si fuera un static archivo preferimos utilizar el templatefile función y entonces usaremos el local_file fuente de datos aquí:
data "local_file" "input_template"
filename = var.input_template_file
data "template_file" "input"
template = data.local_file.input_template.content
vars =
instance_id = aws_instance.example.id
resource "aws_cloudwatch_event_target" "data"
rule = aws_cloudwatch_event_rule.scheduler.name
target_id = "finance_producer_cloudwatch"
arn = aws_lambda_function.finance_data_producer.arn
input = data.template_file.input.rendered
los templatefile La función se agregó en Terraform 0.12.0, por lo que puede ver ejemplos en otros lugares del uso de la template_file fuente de datos para representar static archivos de plantilla. Ese es un patrón antiguo, ahora en desuso en Terraform 0.12, porque el templatefile La función hace que la configuración sea más directa y legible en la mayoría de los casos.
Una peculiaridad del template_file fuente de datos en contraposición a la templatefile función es que la fuente de datos pertenece a la template proveedor en lugar de Terraform Core, por lo que las funciones de plantilla que estén disponibles dependerán de la versión del proveedor que esté instalada en lugar de la versión de Terraform CLI instalada. los template Es probable que el proveedor se quede atrás de Terraform Core en términos de qué funciones de lenguaje de plantilla están disponibles, lo cual es otra razón para preferir el templatefile funcionar siempre que sea posible.
Otras posibilidades
Esta pregunta fue específicamente sobre la lectura de datos de un archivo, pero para completar también quiero señalar que para cargas útiles JSON pequeñas, a veces puede ser preferible incorporarlas directamente en la configuración como una estructura de datos Terraform y convertirlas a JSON usando jsonencode, como esto:
resource "aws_cloudwatch_event_target" "data"
rule = aws_cloudwatch_event_rule.scheduler.name
target_id = "finance_producer_cloudwatch"
arn = aws_lambda_function.finance_data_producer.arn
input = jsonencode(
instance_id = aws_instance.example.id
)
Escribir la estructura de datos en línea como una expresión de Terraform significa que un futuro lector puede ver directamente lo que se enviará sin necesidad de consultar un archivo separado. Sin embargo, si la estructura de datos es muy grande y complicada, puede afectar la legibilidad general para incluirla en línea porque podría abrumar a la otra configuración en el mismo archivo.
Por lo tanto, qué opción elegir dependerá mucho de las circunstancias específicas, pero siempre vale la pena considerar si la dirección indirecta de un archivo separado es la mejor opción para la legibilidad.
Terraform también tiene un yamlencode función (experimental en el momento de escribir este artículo) que puede funcionar de manera similar para las estructuras de datos con formato YAML, ya sea directamente dentro de un .tf archivo o en una secuencia de interpolación en una plantilla externa.
Más adelante puedes encontrar las referencias de otros sys admins, tú aún puedes dejar el tuyo si te gusta.