> **Experimental**
>
> `@aws-cdk/aws-lambda-go-alpha` is an [**experimental**](/stability) (alpha) package: its API may change in any release, without a major version bump.
# BundlingOptions

Bundling options.

Extends: BundlingOptions
Extends: DockerRunOptions

- Stability: [Experimental](/cdk/api/stability.html)
- Source: [`lib/types.ts`](https://github.com/aws/aws-cdk/blob/v2.275.0-alpha.0/packages/@aws-cdk/aws-lambda-go-alpha/lib/types.ts#L6)

## Example

```ts
new go.GoFunction(this, 'handler', {
  entry: 'app/cmd/api',
  bundling: {
    environment: {
      HELLO: 'WORLD',
    },
  },
});
```

## Properties

- `assetHash`: string — Specify a custom hash for this asset.

  **Default:** based on `assetHashType`

  If `assetHashType` is set it must
  be set to `AssetHashType.CUSTOM`. For consistency, this custom hash will
  be SHA256 hashed and encoded as hex. The resulting hash will be the asset
  hash.

  NOTE: the hash is used in order to identify a specific revision of the asset, and
  used for optimizing and caching deployment activities related to this asset such as
  packaging, uploading to Amazon S3, etc. If you chose to customize the hash, you will
  need to make sure it is updated every time the asset changes, or otherwise it is
  possible that some deployments will not be invalidated.

- `assetHashType`: [AssetHashType](/cdk/api/v2/docs/aws-cdk-lib.AssetHashType.html) — Determines how the asset hash is calculated. Assets will get rebuilt and uploaded only if their hash has changed.

  **Default:** AssetHashType.OUTPUT. If `assetHash` is also specified, the default is `CUSTOM`.

  If the asset hash is set to `OUTPUT` (default), the hash is calculated
  after bundling. This means that any change in the output will cause
  the asset to be invalidated and uploaded. Bear in mind that the
  go binary that is output can be different depending on the environment
  that it was compiled in. If you want to control when the output is changed
  it is recommended that you use immutable build images such as
  `public.ecr.aws/bitnami/golang:1.16.3-debian-10-r16`.

  If the asset hash is set to `SOURCE`, then only changes to the source
  directory will cause the asset to rebuild. If your go project has multiple
  Lambda functions this means that an update to any one function could cause
  all the functions to be rebuilt and uploaded.

- `buildArgs`: { [key: string]: string } — Build arguments to pass when building the bundling image.

  **Default:** no build arguments are passed

- `bundlingFileAccess`: [BundlingFileAccess](/cdk/api/v2/docs/aws-cdk-lib.BundlingFileAccess.html) = BundlingFileAccess.BIND_MOUNT — Which option to use to copy the source files to the docker container and output files back.

- `cgoEnabled`: boolean = false — Whether or not to enable cgo during go build.

  This will set the CGO_ENABLED environment variable

- `command`: string[] — The command to run in the container.

  **Default:** run the command defined in the image

- `commandHooks`: [ICommandHooks](/cdk/api/v2/docs/@aws-cdk_aws-lambda-go-alpha.ICommandHooks.html) — Command hooks.

  **Default:** do not run additional commands

  ⚠️ **Security Warning**: Commands are executed directly in the shell environment.
  Only use trusted commands from verified sources. Avoid shell metacharacters
  that could enable command injection attacks.

- `dockerImage`: [DockerImage](/cdk/api/v2/docs/aws-cdk-lib.DockerImage.html) — A custom bundling Docker image.

  **Default:** use the Docker image provided by

- `entrypoint`: string[] — The entrypoint to run in the container.

  **Default:** run the entrypoint defined in the image

- `environment`: { [key: string]: string } — The environment variables to pass to the container.

  **Default:** no environment variables.

- `forcedDockerBundling`: boolean = false — Force bundling in a Docker container even if local bundling is possible.

- `goBuildFlags`: string[] = none — List of additional flags to use while building.

  For example:
  ['ldflags "-s -w"']

  ⚠️ **Security Warning**: These flags are passed directly to the Go build command.
  Only use trusted values as they can execute arbitrary commands during bundling.
  Avoid flags like `-toolexec` with untrusted arguments, and be cautious with
  third-party CDK constructs that may contain malicious build flags.

- `goProxies`: string[] — What Go proxies to use to fetch the packages involved in the build.

  **Default:** Direct access

  Pass a list of proxy addresses in order, and/or the string `'direct'` to
  attempt direct access.

  By default this construct uses no proxies, but a standard Go install would
  use the Google proxy by default. To recreate that behavior, do the following:

  ```ts
  new go.GoFunction(this, 'GoFunction', {
    entry: 'app/cmd/api',
    bundling: {
      goProxies: [go.GoFunction.GOOGLE_GOPROXY, 'direct'],
    },
  });
  ```

- `network`: string — Docker [Networking options](https://docs.docker.com/engine/reference/commandline/run/#connect-a-container-to-a-network---network).

  **Default:** no networking options

- `platform`: string — Set platform if server is multi-platform capable. _Requires Docker Engine API v1.38+_.

  **Default:** no platform specified

  Example value: `linux/amd64`

- `securityOpt`: string — [Security configuration](https://docs.docker.com/engine/reference/run/#security-configuration) when running the docker container.

  **Default:** no security options

- `user`: string — The user to use when running the container.

  **Default:** root or image default

- `volumes`: [DockerVolume](/cdk/api/v2/docs/aws-cdk-lib.DockerVolume.html)[] — Docker volumes to mount.

  **Default:** no volumes are mounted

- `volumesFrom`: string[] — Where to mount the specified volumes from.

  **Default:** no containers are specified to mount volumes from

- `workingDirectory`: string — Working directory inside the container.

  **Default:** image default