Garden is configured via
garden.yml configuration files, which Garden collects and compiles into a Stack Graph of your project.
The project configuration
garden.yml file should be located in the top-level directory of the project's Git repository.
In addition, each of the project's modules'
garden.yml should be located in that module's top-level directory. Modules define all the individual components of your project, including services, tasks and tests.
Lastly, you can define workflows, to codify sequences of Garden commands and custom scripts.
The other docs under the Using Garden go into more details, and we highly recommend reading through all of them.
Below, you'll also find some general information on how to configure a project.
By default, all directories under the project root are scanned for Garden modules, and all files in the same directory as a module configuration file are included as source files for that module. Sometimes, you need more granular control over the context, not least if you have multiple modules in the same directory.
Garden provides three different ways to achieve this:
modules.exclude fields in project configuration files.
".ignore" files, e.g.
exclude fields in module configuration files.
The first two are described below, and the module-specific includes/excludes are described in the section on modules.
By default, all directories under the project root are scanned for Garden modules, except those matching your ignore files. You may want to limit the scope, for example if you only want certain modules as part of a project, or if all your modules are contained in a single directory (in which case it is more efficient to scan only that directory).
modules.exclude fields are a simple way to explicitly specify which directories should be scanned for modules. They both accept a list of POSIX-style paths or globs. For example:
kind: Projectname: my-projectmodules:include:- modules/**/*exclude:- modules/tmp/**/*...
Here we only scan the
modules directory, but exclude the
If you specify a list with
include, only those patterns are included. If you then specify one or more
exclude patterns, those are filtered out of the ones matched by
include. If you only specify
exclude, those patterns will be filtered out of all paths in the project directory.
modules.exclude field is also used to limit the number of files and directories Garden watches for changes while running. Use that if you have a large number of files/directories in your project that you do not need to watch, or if you are seeing excessive CPU/RAM usage. The
modules.include field has no effect on which paths Garden watches for changes.
By default, Garden respects
.gardenignore files and excludes any patterns matched in those files. You can place the ignore files anywhere in your repository, much like
.gitignore files, and they will follow the same semantics.
You can use those to exclude files and directories across the project, both from being scanned for Garden modules and when selecting source files for individual modules. For example, you might put this
.gardenignore file in your project root directory:
This would cause Garden to ignore
public directories across your project/repo, and all
Note that these take precedence over both
modules.include fields in your project config, and
include fields in your module configs. If a path is matched by one of the ignore files, the path will not be included in your project or modules.
You can override which filenames to use as ".ignore" files using the
dotIgnoreFiles field in your project configuration. For example, you might choose to also respect
.gitignore files (this was the default behavior prior to Garden 0.12.0):
kind: Projectname: my-projectdotIgnoreFiles: [.gardenignore, .gitignore]
If you're using Git submodules in your project, please note the following:
You may ignore submodules using .ignore files and include/exclude filters. If a submodule path itself (that is, the path to the submodule directory, not its contents), matches one that is ignored by your .ignore files or exclude filters, or if you specify include filters and the submodule path does not match one of them, the module will not be scanned.
Include/exclude filters (both at the project and module-level) are applied the same way, whether a directory is a submodule or a normal directory.
.ignore files are considered in the context of each git root. This means that a .ignore file that's outside of a submodule will be completely ignored when scanning that submodule. This is by design, to be consistent with normal Git behavior.
We highly recommend reading all the other docs in this section to learn about the different configuration options and entities.
The Variables and Templating guide explains how you can reference across different providers and modules, as well as how to supply secret values to your configuration.