import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem';

Module Dependencies

Installation

You can call Dagger Functions from any other Dagger module in your own Dagger module simply by adding it as a module dependency with dagger install, as in the following example:

dagger install github.com/shykes/daggerverse/[email protected]

This module will be added to your dagger.json:

...
"dependencies": [
  {
    "name": "hello",
    "source": "github.com/shykes/daggerverse/hello@54d86c6002d954167796e41886a47c47d95a626d"
  }
]

When you add a dependency to your module with dagger install, the dependent module will be added to the code-generation routines and can be accessed from your own module's code.

The entrypoint to accessing dependent modules from your own module's code is dag, the Dagger client, which is pre-initialized. It contains all the core types (like Container, Directory, etc.), as well as bindings to any dependencies your module has declared.

Here is an example of accessing the installed hello module from your own module's code:

func (m *MyModule) Greeting(ctx context.Context) (string, error) {
  return dag.Hello().Hello(ctx)
}

@function
async def greeting(self) -> str:
  return await dag.hello().hello()

@func()
async greeting(): Promise<string> {
  return await dag.hello().hello()
}

#[DaggerFunction]
public function greeting(): string
{
    return dag()->hello()->hello();
}

@Function
public String greeting() throws ExecutionException, DaggerQueryException, InterruptedException {
    return dag().hello().hello();
}

Here is a more complex example. It is a Dagger Function that utilizes a module from the Daggerverse to build a Go project, then chains a Dagger API method to open an interactive terminal session in the build directory.

First, install the module:

dagger install github.com/kpenfound/dagger-modules/[email protected]

Next, create a new Dagger Function:

This Dagger Function accepts two arguments - the source directory and a list of build arguments - and does the following:

• It invokes the Golang module via the dag Dagger client.
• It calls a Dagger Function from the module to build the source code and return a just-in-time directory with the compiled binary.
• It chains a core Dagger API method to open an interactive terminal session in the returned directory.

Here is an example call for this Dagger Function:

You can also use local modules as dependencies. However, they must be stored in a sub-directory of your module. For example:

dagger install ./path/to/module

:::note Installing a module using a local path (relative or absolute) is only possible if your module is within the repository root (for Git repositories) or the directory containing the dagger.json file (for all other cases). :::

Uninstallation

To remove a dependency from your Dagger module, use the dagger uninstall command. The dagger uninstall command can be passed either a remote repository reference or a local module name.

The commands below are equivalent:

dagger uninstall hello
dagger uninstall github.com/shykes/daggerverse/hello

Update

To update a dependency in your Dagger module to the latest version (or the version specified), use the dagger update command. The target module must be local.

The commands below are equivalent:

dagger update hello
dagger update github.com/shykes/daggerverse/hello

:::note Given a dependency like github.com/path/name@branch/tag:

• dagger update github.com/path/name updates the dependency to the latest commit of the branch/tag.
• dagger update github.com/path/name@version updates the dependency to the latest commit for the version branch/tag. :::