# The schema version of this config (currently not used).
# The type of this module.
# The name of this module.
# Specify how to build the module. Note that plugins may define additional keys on this object.
# A list of modules that must be built before this module is built.
- # Module name to build ahead of this module.
# Specify one or more files or directories to copy from the built dependency to this module.
- # POSIX-style path or filename of the directory or file(s) to copy to the target.
# POSIX-style path or filename to copy the directory or file(s), relative to the build directory.
# Defaults to to same as source path.
# Maximum time in seconds to wait for build to finish.
# A description of the module.
# Set this to `true` to disable the module. You can use this with conditional template strings to disable modules
# based on, for example, the current environment or other variables (e.g. `disabled: \${environment.name == "prod"}`).
# This can be handy when you only need certain modules for specific environments, e.g. only for development.
# Disabling a module means that any services, tasks and tests contained in it will not be deployed or run. It also
# means that the module is not built _unless_ it is declared as a build dependency by another enabled module (in which
# case building this module is necessary for the dependant to be built).
# If you disable the module, and its services, tasks or tests are referenced as _runtime_ dependencies, Garden will
# automatically ignore those dependency declarations. Note however that template strings referencing the module's
# service or task outputs (i.e. runtime outputs) will fail to resolve when the module is disabled, so you need to make
# sure to provide alternate values for those if you're using them, using conditional expressions.
# Specify a list of POSIX-style paths or globs that should be regarded as the source files for this module. Files that
# do *not* match these paths or globs are excluded when computing the version of the module, when responding to
# filesystem watch events, and when staging builds.
# Note that you can also _exclude_ files using the `exclude` field or by placing `.gardenignore` files in your source
# tree, which use the same format as `.gitignore` files. See the [Configuration Files
# guide](https://docs.garden.io/using-garden/configuration-overview#including-excluding-files-and-directories) for
# Also note that specifying an empty list here means _no sources_ should be included.
# Specify a list of POSIX-style paths or glob patterns that should be excluded from the module. Files that match these
# paths or globs are excluded when computing the version of the module, when responding to filesystem watch events,
# and when staging builds.
# Note that you can also explicitly _include_ files using the `include` field. If you also specify the `include`
# field, the files/patterns specified here are filtered from the files matched by `include`. See the [Configuration
# Files guide](https://docs.garden.io/using-garden/configuration-overview#including-excluding-files-and-directories)
# Unlike the `modules.exclude` field in the project config, the filters here have _no effect_ on which files and
# directories are watched for changes. Use the project `modules.exclude` field to affect those, if you have large
# directories that should not be watched for changes.
# A remote repository URL. Currently only supports git servers. Must contain a hash suffix pointing to a specific
# branch or tag, with the format: <git remote url>#<branch|tag>
# Garden will import the repository source code into this module, but read the module's config from the local
# When false, disables pushing this module to remote registries.
# A list of files to write to the module directory when resolving this module. This is useful to automatically
# generate (and template) any supporting files needed for the module.
- # POSIX-style filename to read the source file contents from, relative to the path of the module (or the
# ModuleTemplate configuration file if one is being applied).
# This file may contain template strings, much like any other field in the configuration.
# POSIX-style filename to write the resolved file contents to, relative to the path of the module source directory
# (for remote modules this means the root of the module repository, otherwise the directory of the module
# Note that any existing file with the same name will be overwritten. If the path contains one or more
# directories, they will be automatically created if missing.
# By default, Garden will attempt to resolve any Garden template strings in source files. Set this to false to
# skip resolving template strings. Note that this does not apply when setting the `value` field, since that's
# resolved earlier when parsing the configuration.
# The desired file contents as a string.
# A map of variables scoped to this particular module. These are resolved before any other parts of the module
# configuration and take precedence over project-scoped variables. They may reference project-scoped variables, and
# generally use any template strings normally allowed when resolving modules.
# Specify a path (relative to the module root) to a file containing variables, that we apply on top of the
# module-level `variables` field.
# The format of the files is determined by the configured file's extension:
# * `.env` - Standard "dotenv" format, as defined by [dotenv](https://github.com/motdotla/dotenv#rules).
# * `.yaml`/`.yml` - YAML. The file must consist of a YAML document, which must be a map (dictionary). Keys may
# contain any value type.
# * `.json` - JSON. Must contain a single JSON _object_ (not an array).
# _NOTE: The default varfile format will change to YAML in Garden v0.13, since YAML allows for definition of nested
# To use different module-level varfiles in different environments, you can template in the environment name
# to the varfile name, e.g. `varfile: "my-module.\$\{environment.name\}.env` (this assumes that the corresponding
# If set to true, Garden will destroy the stack when calling `garden delete env` or `garden delete service <module
# This is useful to prevent unintentional destroys in production or shared environments.
# If set to false, deployments will fail unless a `planPath` is provided for this module. This is useful when
# production or shared environments, or when the module deploys infrastructure that you don't want to unintentionally
# If set to true, Garden will automatically create the stack if it doesn't already exist.
# The names of any services that this service depends on at runtime, and the names of any tasks that should be
# executed before this service is deployed.
# Specify the path to the Pulumi project root, relative to the module root.
# A map of config variables to use when applying the stack. These are merged with the contents of any `pulumiVarfiles`
# for this module. The module's stack config will be overwritten with the resulting merged config.
# Variables declared here override any conflicting config variables defined in this module's `pulumiVarfiles`.
# Note: `pulumiVariables` should not include runtime outputs from other pulumi modules when `cacheStatus` is set to
# the outputs may change from the time the stack status of the dependency module is initially queried to when it's
# Instead, use pulumi stack references when using the `cacheStatus` config option.
# Specify one or more paths (relative to the module root) to YAML files containing pulumi config variables.
# Templated paths that resolve to `null`, `undefined` or an empty string are ignored.
# Any Garden template strings in these varfiles will be resolved when the files are loaded.
# Each file must consist of a single YAML document, which must be a map (dictionary). Keys may contain any
# If one or more varfiles is not found, no error is thrown (that varfile path is simply ignored).
# Note: There is no need to nest the variables under a `config` field as is done in a pulumi
# config. Simply specify all the config variables at the top level.
# The name of the pulumi organization to use. Overrides the `orgName` set on the pulumi provider (if any).
# To use the default org, set to null.
# When set to true, the pulumi stack will be tagged with the Garden service version when deploying. The tag
# will then be used for service status checks for this service. If the version doesn't change between deploys,
# the subsequent deploy is skipped.
# Note that this will not pick up changes to stack outputs referenced via stack references in your pulumi stack,
# unless they're referenced via template strings in the module configuration.
# When using stack references to other pulumi modules in your project, we recommend including them in this
# module's `stackReferences` config field (see the documentation for that field on this page).
# When setting `cacheStatus` to true for this module, you should include all stack references used by this
# module's pulumi stack in this field.
# This lets Garden know to redeploy the pulumi stack if the output values of one or more of these stack references
# have changed since the last deployment.
# When set to true, will use pulumi plans generated by the `garden plugins pulumi preview` command when
# deploying, and will fail if no plan exists locally for the module.
# When this option is used, the pulumi plugin bypasses the status check altogether and passes the plan directly
# to `pulumi up` (via the `--plan` option, which is experimental as of March 2022). You should therefore
# take care to only use this config option when you're sure you want to apply the changes in the plan.
# This option is intended for two-phase pulumi deployments, where pulumi preview diffs are first reviewed (e.g.
# The name of the pulumi stack to use. Defaults to the current environment name.