pulumi_gestalt_schema 0.0.12

Pulumi schema reader
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

<!-- Bug: Type and Name are switched -->
Manages the lifecycle of a Docker container.

## Example Usage

<!--Start PulumiCodeChooser -->
```typescript
import * as pulumi from "@pulumi/pulumi";
import * as docker from "@pulumi/docker";

// Find the latest Ubuntu precise image.
const ubuntuRemoteImage = new docker.RemoteImage("ubuntuRemoteImage", {name: "ubuntu:precise"});
// Start a container
const ubuntuContainer = new docker.Container("ubuntuContainer", {image: ubuntuRemoteImage.imageId});
```
```python
import pulumi
import pulumi_docker as docker

# Find the latest Ubuntu precise image.
ubuntu_remote_image = docker.RemoteImage("ubuntuRemoteImage", name="ubuntu:precise")
# Start a container
ubuntu_container = docker.Container("ubuntuContainer", image=ubuntu_remote_image.image_id)
```
```csharp
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Docker = Pulumi.Docker;

return await Deployment.RunAsync(() => 
{
    // Find the latest Ubuntu precise image.
    var ubuntuRemoteImage = new Docker.RemoteImage("ubuntuRemoteImage", new()
    {
        Name = "ubuntu:precise",
    });

    // Start a container
    var ubuntuContainer = new Docker.Container("ubuntuContainer", new()
    {
        Image = ubuntuRemoteImage.ImageId,
    });

});
```
```go
package main

import (
	"github.com/pulumi/pulumi-docker/sdk/v4/go/docker"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Find the latest Ubuntu precise image.
		ubuntuRemoteImage, err := docker.NewRemoteImage(ctx, "ubuntuRemoteImage", &docker.RemoteImageArgs{
			Name: pulumi.String("ubuntu:precise"),
		})
		if err != nil {
			return err
		}
		// Start a container
		_, err = docker.NewContainer(ctx, "ubuntuContainer", &docker.ContainerArgs{
			Image: ubuntuRemoteImage.ImageId,
		})
		if err != nil {
			return err
		}
		return nil
	})
}
```
```java
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.docker.RemoteImage;
import com.pulumi.docker.RemoteImageArgs;
import com.pulumi.docker.Container;
import com.pulumi.docker.ContainerArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var ubuntuRemoteImage = new RemoteImage("ubuntuRemoteImage", RemoteImageArgs.builder()        
            .name("ubuntu:precise")
            .build());

        var ubuntuContainer = new Container("ubuntuContainer", ContainerArgs.builder()        
            .image(ubuntuRemoteImage.imageId())
            .build());

    }
}
```
```yaml
resources:
  # Start a container
  ubuntuContainer:
    type: docker:Container
    properties:
      image: ${ubuntuRemoteImage.imageId}
  # Find the latest Ubuntu precise image.
  ubuntuRemoteImage:
    type: docker:RemoteImage
    properties:
      name: ubuntu:precise
```
<!--End PulumiCodeChooser -->

## Import

### Example

Assuming you created a `container` as follows

```sh
docker run --name foo -p8080:80 -d nginx 
```

prints the container ID 

```text
9a550c0f0163d39d77222d3efd58701b625d47676c25c686c95b5b92d1cba6fd
```

you provide the definition for the resource as follows

<!--Start PulumiCodeChooser -->
```yaml
resources:
  foo:
    type: docker:Container
    properties:
      name: "foo"
      image: "nginx"
      ports:
        - internal: 80
          external: 8080
```
<!--End PulumiCodeChooser -->

then the import command is as follows

```sh
$ pulumi import docker:index/container:Container foo 9a550c0f0163d39d77222d3efd58701b625d47676c25c686c95b5b92d1cba6fd
```