# Herencia en Bake


Los objetivos (targets) pueden heredar atributos de otros objetivos mediante el atributo `inherits`. Por ejemplo, imagina que tienes un objetivo que compila una imagen de Docker para un entorno de desarrollo:

```hcl {title=docker-bake.hcl}
target "app-dev" {
  args = {
    GO_VERSION = "1.25"
  }
  tags = ["docker.io/username/myapp:dev"]
  labels = {
    "org.opencontainers.image.source" = "https://github.com/username/myapp"
    "org.opencontainers.image.author" = "moby.whale@example.com"
  }
}
```

Puedes crear un nuevo objetivo que use la misma configuración de compilación, pero con atributos ligeramente diferentes para una compilación de producción. En este ejemplo, el objetivo `app-release` hereda del objetivo `app-dev`, pero sobrescribe el atributo `tags` y añade un nuevo atributo `platforms`:

```hcl {title=docker-bake.hcl}
target "app-release" {
  inherits = ["app-dev"]
  tags = ["docker.io/username/myapp:latest"]
  platforms = ["linux/amd64", "linux/arm64"]
}
```

## Objetivos comunes reutilizables

Un patrón de herencia común consiste en definir un objetivo base o común que contenga atributos compartidos por todos o por muchos de los objetivos de compilación del proyecto. Por ejemplo, el siguiente objetivo `_common` define un conjunto común de argumentos de compilación:

```hcl {title=docker-bake.hcl}
target "_common" {
  args = {
    GO_VERSION = "1.25"
    BUILDKIT_CONTEXT_KEEP_GIT_DIR = 1
  }
}
```

Luego puedes heredar del objetivo `_common` en otros objetivos para aplicar los atributos compartidos:

```hcl {title=docker-bake.hcl}
target "lint" {
  inherits = ["_common"]
  dockerfile = "./dockerfiles/lint.Dockerfile"
  output = [{ type = "cacheonly" }]
}

target "docs" {
  inherits = ["_common"]
  dockerfile = "./dockerfiles/docs.Dockerfile"
  output = ["./docs/reference"]
}

target "test" {
  inherits = ["_common"]
  target = "test-output"
  output = ["./test"]
}

target "binaries" {
  inherits = ["_common"]
  target = "binaries"
  output = ["./build"]
  platforms = ["local"]
}
```

## Sobrescribir atributos heredados

Cuando un objetivo hereda de otro, puede sobrescribir cualquiera de los atributos heredados. Por ejemplo, el siguiente objetivo sobrescribe el atributo `args` del objetivo heredado:

```hcl {title=docker-bake.hcl}
target "app-dev" {
  inherits = ["_common"]
  args = {
    GO_VERSION = "1.17"
  }
  tags = ["docker.io/username/myapp:dev"]
}
```

El argumento `GO_VERSION` en `app-dev` se establece en `1.17`, sobrescribiendo el argumento `GO_VERSION` del objetivo `_common`.

Para obtener más información sobre cómo sobrescribir atributos, consulta la página [Sobrescribir configuraciones](/build/bake/overrides/).

## Heredar de múltiples objetivos

El atributo `inherits` es una lista, lo que significa que puedes reutilizar atributos de múltiples objetivos. En el siguiente ejemplo, el objetivo `app-release` reutiliza atributos tanto del objetivo `app-dev` como del objetivo `_common`.

```hcl {title=docker-bake.hcl}
target "_common" {
  args = {
    GO_VERSION = "1.25"
    BUILDKIT_CONTEXT_KEEP_GIT_DIR = 1
  }
}

target "app-dev" {
  inherits = ["_common"]
  args = {
    BUILDKIT_CONTEXT_KEEP_GIT_DIR = 0
  }
  tags = ["docker.io/username/myapp:dev"]
  labels = {
    "org.opencontainers.image.source" = "https://github.com/username/myapp"
    "org.opencontainers.image.author" = "moby.whale@example.com"
  }
}

target "app-release" {
  inherits = ["app-dev", "_common"]
  tags = ["docker.io/username/myapp:latest"]
  platforms = ["linux/amd64", "linux/arm64"]
}
```

Cuando se heredan atributos de múltiples objetivos y hay un conflicto, el objetivo que aparece al final de la lista `inherits` tiene prioridad. El ejemplo anterior define `BUILDKIT_CONTEXT_KEEP_GIT_DIR` en el objetivo `_common` y lo sobrescribe en el objetivo `app-dev`.

El objetivo `app-release` hereda tanto de `app-dev` como de `_common`. El argumento `BUILDKIT_CONTEXT_KEEP_GIT_DIR` se establece en 0 en `app-dev` y en 1 en `_common`. El argumento `BUILDKIT_CONTEXT_KEEP_GIT_DIR` en el objetivo `app-release` se establece en 1, no en 0, debido a que el objetivo `_common` aparece en último lugar en la lista de herencia.

## Reutilizar atributos individuales de objetivos

Si solo deseas heredar un único atributo de un objetivo, puedes hacer referencia a un atributo de otro objetivo mediante la notación de punto. Por ejemplo, en el siguiente archivo de Bake, el objetivo `bar` reutiliza el atributo `tags` del objetivo `foo`:

```hcl {title=docker-bake.hcl}
target "foo" {
  dockerfile = "foo.Dockerfile"
  tags       = ["myapp:latest"]
}
target "bar" {
  dockerfile = "bar.Dockerfile"
  tags       = target.foo.tags
}
```