# MultipartUserData

Mime multipart user data.

This class represents MIME multipart user data, as described in.
[Specifying Multiple User Data Blocks Using a MIME Multi Part Archive](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#multi-part_user_data)

Extends: [UserData](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2.UserData.html) › MultipartUserData

- Source: [`aws-ec2/lib/user-data.ts`](https://github.com/aws/aws-cdk/blob/v2.278.0/packages/aws-cdk-lib/aws-ec2/lib/user-data.ts#L466)

## Example

TypeScript:

```ts
const bootHookConf = ec2.UserData.forLinux();
bootHookConf.addCommands('cloud-init-per once docker_options echo \'OPTIONS="${OPTIONS} --storage-opt dm.basesize=40G"\' >> /etc/sysconfig/docker');

const setupCommands = ec2.UserData.forLinux();
setupCommands.addCommands('sudo yum install awscli && echo Packages installed らと > /var/tmp/setup');

const multipartUserData = new ec2.MultipartUserData();
// The docker has to be configured at early stage, so content type is overridden to boothook
multipartUserData.addPart(ec2.MultipartBody.fromUserData(bootHookConf, 'text/cloud-boothook; charset="us-ascii"'));
// Execute the rest of setup
multipartUserData.addPart(ec2.MultipartBody.fromUserData(setupCommands));

new ec2.LaunchTemplate(this, '', {
  userData: multipartUserData,
  blockDevices: [
    // Block device configuration rest
  ]
});
```

Python:

```python
boot_hook_conf = ec2.UserData.for_linux()
boot_hook_conf.add_commands("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker")

setup_commands = ec2.UserData.for_linux()
setup_commands.add_commands("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup")

multipart_user_data = ec2.MultipartUserData()
# The docker has to be configured at early stage, so content type is overridden to boothook
multipart_user_data.add_part(ec2.MultipartBody.from_user_data(boot_hook_conf, "text/cloud-boothook; charset=\"us-ascii\""))
# Execute the rest of setup
multipart_user_data.add_part(ec2.MultipartBody.from_user_data(setup_commands))

ec2.LaunchTemplate(self, "",
    user_data=multipart_user_data,
    block_devices=[]
)
```

Java:

```java
UserData bootHookConf = UserData.forLinux();
bootHookConf.addCommands("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker");

UserData setupCommands = UserData.forLinux();
setupCommands.addCommands("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup");

MultipartUserData multipartUserData = new MultipartUserData();
// The docker has to be configured at early stage, so content type is overridden to boothook
multipartUserData.addPart(MultipartBody.fromUserData(bootHookConf, "text/cloud-boothook; charset=\"us-ascii\""));
// Execute the rest of setup
multipartUserData.addPart(MultipartBody.fromUserData(setupCommands));

LaunchTemplate.Builder.create(this, "")
        .userData(multipartUserData)
        .blockDevices(List.of())
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
var bootHookConf = UserData.ForLinux();
bootHookConf.AddCommands("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker");

var setupCommands = UserData.ForLinux();
setupCommands.AddCommands("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup");

var multipartUserData = new MultipartUserData();
// The docker has to be configured at early stage, so content type is overridden to boothook
multipartUserData.AddPart(MultipartBody.FromUserData(bootHookConf, "text/cloud-boothook; charset=\"us-ascii\""));
// Execute the rest of setup
multipartUserData.AddPart(MultipartBody.FromUserData(setupCommands));

new LaunchTemplate(this, "", new LaunchTemplateProps {
    UserData = multipartUserData,
    BlockDevices = new [] {  }
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
bootHookConf := ec2.UserData_ForLinux()
bootHookConf.AddCommands(jsii.String("cloud-init-per once docker_options echo 'OPTIONS=\"${OPTIONS} --storage-opt dm.basesize=40G\"' >> /etc/sysconfig/docker"))

setupCommands := ec2.UserData_ForLinux()
setupCommands.AddCommands(jsii.String("sudo yum install awscli && echo Packages installed らと > /var/tmp/setup"))

multipartUserData := ec2.NewMultipartUserData()
// The docker has to be configured at early stage, so content type is overridden to boothook
multipartUserData.AddPart(ec2.MultipartBody_FromUserData(bootHookConf, jsii.String("text/cloud-boothook; charset=\"us-ascii\"")))
// Execute the rest of setup
multipartUserData.AddPart(ec2.MultipartBody_FromUserData(setupCommands))

ec2.NewLaunchTemplate(this, jsii.String(""), &LaunchTemplateProps{
	UserData: multipartUserData,
	BlockDevices: []BlockDevice{
	},
})
```

## Initializer

TypeScript:

```ts
new MultipartUserData(opts?: MultipartUserDataOptions)
```

Python:

```python
MultipartUserData(opts: typing.Optional[MultipartUserDataOptions] = None)
```

Java:

```java
new MultipartUserData(MultipartUserDataOptions opts)
```

C# / .NET:

```csharp
new MultipartUserData(MultipartUserDataOptions? opts = null)
```

Golang:

```go
NewMultipartUserData(Opts MultipartUserDataOptions)
```

## Methods

- `addCommands(...commands: string[]): void` — Add one or more commands to the user data.

- `addExecuteFileCommand(params: ExecuteFileOptions): void` — Adds commands to execute a file.

- `addOnExitCommands(...commands: string[]): void` — Add one or more commands to the user data that will run when the script exits.

- `addPart(part: MultipartBody): void` — Adds a part to the list of parts.

- `addS3DownloadCommand(params: S3DownloadOptions): string` — Adds commands to download a file from S3.

- `addSignalOnExitCommand(resource: Resource): void` — Adds a command which will send a cfn-signal when the user data script ends.

- `addUserDataPart(userData: UserData, contentType?: string, makeDefault?: boolean): void` — Adds a multipart part based on a UserData object.

  If `makeDefault` is true, then the UserData added by this method
  will also be the target of calls to the `add*Command` methods on
  this MultipartUserData object.

  If `makeDefault` is false, then this is the same as calling:

  ```ts
  declare const multiPart: ec2.MultipartUserData;
  declare const userData: ec2.UserData;
  declare const contentType: string;

  multiPart.addPart(ec2.MultipartBody.fromUserData(userData, contentType));
  ```

  An undefined `makeDefault` defaults to either:
  - `true` if no default UserData has been set yet; or
  - `false` if there is no default UserData set.

- `custom(content: string): UserData` (static) — Create a userdata object with custom content.

- `forLinux(options?: LinuxUserDataOptions): UserData` (static) — Create a userdata object for Linux hosts.

- `forOperatingSystem(os: OperatingSystemType): UserData` (static)

- `forWindows(options?: WindowsUserDataOptions): UserData` (static) — Create a userdata object for Windows hosts.

- `render(): string` — Render the UserData for use in a construct.
