pulumi-docker 4.7.0a1747374653__py3-none-any.whl → 4.7.0a1747852246__py3-none-any.whl

pulumi_docker/network.py

@@ -51,6 +51,9 @@ class NetworkArgs:
         """
         if attachable is not None:
             pulumi.set(__self__, "attachable", attachable)
+        if check_duplicate is not None:
+            warnings.warn("""This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""", DeprecationWarning)
+            pulumi.log.warn("""check_duplicate is deprecated: This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""")
         if check_duplicate is not None:
             pulumi.set(__self__, "check_duplicate", check_duplicate)
         if driver is not None:
@@ -88,6 +91,7 @@ class NetworkArgs:
 
     @property
     @pulumi.getter(name="checkDuplicate")
+    @_utilities.deprecated("""This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""")
     def check_duplicate(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
         Requests daemon to check for networks with same name.
@@ -253,6 +257,9 @@ class _NetworkState:
         """
         if attachable is not None:
             pulumi.set(__self__, "attachable", attachable)
+        if check_duplicate is not None:
+            warnings.warn("""This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""", DeprecationWarning)
+            pulumi.log.warn("""check_duplicate is deprecated: This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""")
         if check_duplicate is not None:
             pulumi.set(__self__, "check_duplicate", check_duplicate)
         if driver is not None:
@@ -292,6 +299,7 @@ class _NetworkState:
 
     @property
     @pulumi.getter(name="checkDuplicate")
+    @_utilities.deprecated("""This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""")
     def check_duplicate(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
         Requests daemon to check for networks with same name.
@@ -687,6 +695,7 @@ class Network(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="checkDuplicate")
+    @_utilities.deprecated("""This option is deprecated and will be removed in a future version. The Docker daemon will always check for duplicate networks.""")
     def check_duplicate(self) -> pulumi.Output[Optional[builtins.bool]]:
         """
         Requests daemon to check for networks with same name.

pulumi_docker/outputs.py

@@ -37,8 +37,10 @@ __all__ = [
     'NetworkIpamConfig',
     'NetworkLabel',
     'PluginGrantPermission',
+    'RegistryImageAuthConfig',
     'RemoteImageBuild',
     'RemoteImageBuildAuthConfig',
+    'RemoteImageBuildSecret',
     'RemoteImageBuildUlimit',
     'SecretLabel',
     'ServiceAuth',
@@ -77,6 +79,8 @@ __all__ = [
     'ServiceUpdateConfig',
     'VolumeLabel',
     'GetNetworkIpamConfigResult',
+    'GetRegistryImageManifestsAuthConfigResult',
+    'GetRegistryImageManifestsManifestResult',
 ]
 
 @pulumi.output_type
@@ -176,7 +180,9 @@ class ContainerHealthcheck(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "startPeriod":
+        if key == "startInterval":
+            suggest = "start_interval"
+        elif key == "startPeriod":
             suggest = "start_period"
 
         if suggest:
@@ -194,12 +200,14 @@ class ContainerHealthcheck(dict):
                  tests: Sequence[builtins.str],
                  interval: Optional[builtins.str] = None,
                  retries: Optional[builtins.int] = None,
+                 start_interval: Optional[builtins.str] = None,
                  start_period: Optional[builtins.str] = None,
                  timeout: Optional[builtins.str] = None):
         """
         :param Sequence[builtins.str] tests: Command to run to check health. For example, to run `curl -f localhost/health` set the command to be `["CMD", "curl", "-f", "localhost/health"]`.
         :param builtins.str interval: Time between running the check (ms|s|m|h). Defaults to `0s`.
         :param builtins.int retries: Consecutive failures needed to report unhealthy. Defaults to `0`.
+        :param builtins.str start_interval: Interval before the healthcheck starts (ms|s|m|h). Defaults to `0s`.
         :param builtins.str start_period: Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
         :param builtins.str timeout: Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
         """
@@ -208,6 +216,8 @@ class ContainerHealthcheck(dict):
             pulumi.set(__self__, "interval", interval)
         if retries is not None:
             pulumi.set(__self__, "retries", retries)
+        if start_interval is not None:
+            pulumi.set(__self__, "start_interval", start_interval)
         if start_period is not None:
             pulumi.set(__self__, "start_period", start_period)
         if timeout is not None:
@@ -237,6 +247,14 @@ class ContainerHealthcheck(dict):
         """
         return pulumi.get(self, "retries")
 
+    @property
+    @pulumi.getter(name="startInterval")
+    def start_interval(self) -> Optional[builtins.str]:
+        """
+        Interval before the healthcheck starts (ms|s|m|h). Defaults to `0s`.
+        """
+        return pulumi.get(self, "start_interval")
+
     @property
     @pulumi.getter(name="startPeriod")
     def start_period(self) -> Optional[builtins.str]:
@@ -518,12 +536,14 @@ class ContainerMountVolumeOptions(dict):
                  driver_name: Optional[builtins.str] = None,
                  driver_options: Optional[Mapping[str, builtins.str]] = None,
                  labels: Optional[Sequence['outputs.ContainerMountVolumeOptionsLabel']] = None,
-                 no_copy: Optional[builtins.bool] = None):
+                 no_copy: Optional[builtins.bool] = None,
+                 subpath: Optional[builtins.str] = None):
         """
         :param builtins.str driver_name: Name of the driver to use to create the volume.
         :param Mapping[str, builtins.str] driver_options: key/value map of driver specific options.
         :param Sequence['ContainerMountVolumeOptionsLabelArgs'] labels: User-defined key/value metadata.
         :param builtins.bool no_copy: Populate volume with data from the target.
+        :param builtins.str subpath: Path within the volume to mount. Requires docker server version 1.45 or higher.
         """
         if driver_name is not None:
             pulumi.set(__self__, "driver_name", driver_name)
@@ -533,6 +553,8 @@ class ContainerMountVolumeOptions(dict):
             pulumi.set(__self__, "labels", labels)
         if no_copy is not None:
             pulumi.set(__self__, "no_copy", no_copy)
+        if subpath is not None:
+            pulumi.set(__self__, "subpath", subpath)
 
     @property
     @pulumi.getter(name="driverName")
@@ -566,6 +588,14 @@ class ContainerMountVolumeOptions(dict):
         """
         return pulumi.get(self, "no_copy")
 
+    @property
+    @pulumi.getter
+    def subpath(self) -> Optional[builtins.str]:
+        """
+        Path within the volume to mount. Requires docker server version 1.45 or higher.
+        """
+        return pulumi.get(self, "subpath")
+
 
 @pulumi.output_type
 class ContainerMountVolumeOptionsLabel(dict):
@@ -921,6 +951,7 @@ class ContainerUpload(dict):
                  content: Optional[builtins.str] = None,
                  content_base64: Optional[builtins.str] = None,
                  executable: Optional[builtins.bool] = None,
+                 permissions: Optional[builtins.str] = None,
                  source: Optional[builtins.str] = None,
                  source_hash: Optional[builtins.str] = None):
         """
@@ -928,6 +959,7 @@ class ContainerUpload(dict):
         :param builtins.str content: Literal string value to use as the object content, which will be uploaded as UTF-8-encoded text. Conflicts with `content_base64` & `source`
         :param builtins.str content_base64: Base64-encoded data that will be decoded and uploaded as raw bytes for the object content. This allows safely uploading non-UTF8 binary data, but is recommended only for larger binary content such as the result of the `base64encode` interpolation function. See here for the reason. Conflicts with `content` & `source`
         :param builtins.bool executable: If `true`, the file will be uploaded with user executable permission. Defaults to `false`.
+        :param builtins.str permissions: The permission mode for the file in the container. Has precedence over `executable`.
         :param builtins.str source: A filename that references a file which will be uploaded as the object content. This allows for large file uploads that do not get stored in state. Conflicts with `content` & `content_base64`
         :param builtins.str source_hash: If using `source`, this will force an update if the file content has updated but the filename has not.
         """
@@ -938,6 +970,8 @@ class ContainerUpload(dict):
             pulumi.set(__self__, "content_base64", content_base64)
         if executable is not None:
             pulumi.set(__self__, "executable", executable)
+        if permissions is not None:
+            pulumi.set(__self__, "permissions", permissions)
         if source is not None:
             pulumi.set(__self__, "source", source)
         if source_hash is not None:
@@ -975,6 +1009,14 @@ class ContainerUpload(dict):
         """
         return pulumi.get(self, "executable")
 
+    @property
+    @pulumi.getter
+    def permissions(self) -> Optional[builtins.str]:
+        """
+        The permission mode for the file in the container. Has precedence over `executable`.
+        """
+        return pulumi.get(self, "permissions")
+
     @property
     @pulumi.getter
     def source(self) -> Optional[builtins.str]:
@@ -1216,6 +1258,46 @@ class PluginGrantPermission(dict):
         return pulumi.get(self, "values")
 
 
+@pulumi.output_type
+class RegistryImageAuthConfig(dict):
+    def __init__(__self__, *,
+                 address: builtins.str,
+                 password: builtins.str,
+                 username: builtins.str):
+        """
+        :param builtins.str address: The address of the Docker registry.
+        :param builtins.str password: The password for the Docker registry.
+        :param builtins.str username: The username for the Docker registry.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "password", password)
+        pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter
+    def address(self) -> builtins.str:
+        """
+        The address of the Docker registry.
+        """
+        return pulumi.get(self, "address")
+
+    @property
+    @pulumi.getter
+    def password(self) -> builtins.str:
+        """
+        The password for the Docker registry.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter
+    def username(self) -> builtins.str:
+        """
+        The username for the Docker registry.
+        """
+        return pulumi.get(self, "username")
+
+
 @pulumi.output_type
 class RemoteImageBuild(dict):
     @staticmethod
@@ -1223,12 +1305,12 @@ class RemoteImageBuild(dict):
         suggest = None
         if key == "authConfigs":
             suggest = "auth_configs"
-        elif key == "buildArg":
-            suggest = "build_arg"
         elif key == "buildArgs":
             suggest = "build_args"
         elif key == "buildId":
             suggest = "build_id"
+        elif key == "buildLogFile":
+            suggest = "build_log_file"
         elif key == "cacheFroms":
             suggest = "cache_froms"
         elif key == "cgroupParent":
@@ -1280,9 +1362,10 @@ class RemoteImageBuild(dict):
     def __init__(__self__, *,
                  context: builtins.str,
                  auth_configs: Optional[Sequence['outputs.RemoteImageBuildAuthConfig']] = None,
-                 build_arg: Optional[Mapping[str, builtins.str]] = None,
                  build_args: Optional[Mapping[str, builtins.str]] = None,
                  build_id: Optional[builtins.str] = None,
+                 build_log_file: Optional[builtins.str] = None,
+                 builder: Optional[builtins.str] = None,
                  cache_froms: Optional[Sequence[builtins.str]] = None,
                  cgroup_parent: Optional[builtins.str] = None,
                  cpu_period: Optional[builtins.int] = None,
@@ -1304,6 +1387,7 @@ class RemoteImageBuild(dict):
                  pull_parent: Optional[builtins.bool] = None,
                  remote_context: Optional[builtins.str] = None,
                  remove: Optional[builtins.bool] = None,
+                 secrets: Optional[Sequence['outputs.RemoteImageBuildSecret']] = None,
                  security_opts: Optional[Sequence[builtins.str]] = None,
                  session_id: Optional[builtins.str] = None,
                  shm_size: Optional[builtins.int] = None,
@@ -1314,11 +1398,12 @@ class RemoteImageBuild(dict):
                  ulimits: Optional[Sequence['outputs.RemoteImageBuildUlimit']] = None,
                  version: Optional[builtins.str] = None):
         """
-        :param builtins.str context: Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
+        :param builtins.str context: Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. This always refers to the local working directory, even when building images on remote hosts. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
         :param Sequence['RemoteImageBuildAuthConfigArgs'] auth_configs: The configuration for the authentication
-        :param Mapping[str, builtins.str] build_arg: Set build-time variables
-        :param Mapping[str, builtins.str] build_args: Pairs for build-time variables in the form TODO
+        :param Mapping[str, builtins.str] build_args: Pairs for build-time variables in the form of `ENDPOINT : "https://example.com"`
         :param builtins.str build_id: BuildID is an optional identifier that can be passed together with the build request. The same identifier can be used to gracefully cancel the build with the cancel request.
+        :param builtins.str build_log_file: Path to a file where the buildx log are written to. Only available when `builder` is set. If not set, no logs are available. The path is taken as is, so make sure to use a path that is available.
+        :param builtins.str builder: Set the name of the buildx builder to use. If not set or empty, the legacy builder will be used.
         :param Sequence[builtins.str] cache_froms: Images to consider as cache sources
         :param builtins.str cgroup_parent: Optional parent cgroup for the container
         :param builtins.int cpu_period: The length of a CPU period in microseconds
@@ -1338,8 +1423,9 @@ class RemoteImageBuild(dict):
         :param builtins.bool no_cache: Do not use the cache when building the image
         :param builtins.str platform: Set platform if server is multi-platform capable
         :param builtins.bool pull_parent: Attempt to pull the image even if an older image exists locally
-        :param builtins.str remote_context: A Git repository URI or HTTP/HTTPS context URI
+        :param builtins.str remote_context: A Git repository URI or HTTP/HTTPS context URI. Will be ignored if `builder` is set.
         :param builtins.bool remove: Remove intermediate containers after a successful build. Defaults to `true`.
+        :param Sequence['RemoteImageBuildSecretArgs'] secrets: Set build-time secrets. Only available when you use a buildx builder.
         :param Sequence[builtins.str] security_opts: The security options
         :param builtins.str session_id: Set an ID for the build session
         :param builtins.int shm_size: Size of /dev/shm in bytes. The size must be greater than 0
@@ -1353,12 +1439,14 @@ class RemoteImageBuild(dict):
         pulumi.set(__self__, "context", context)
         if auth_configs is not None:
             pulumi.set(__self__, "auth_configs", auth_configs)
-        if build_arg is not None:
-            pulumi.set(__self__, "build_arg", build_arg)
         if build_args is not None:
             pulumi.set(__self__, "build_args", build_args)
         if build_id is not None:
             pulumi.set(__self__, "build_id", build_id)
+        if build_log_file is not None:
+            pulumi.set(__self__, "build_log_file", build_log_file)
+        if builder is not None:
+            pulumi.set(__self__, "builder", builder)
         if cache_froms is not None:
             pulumi.set(__self__, "cache_froms", cache_froms)
         if cgroup_parent is not None:
@@ -1401,6 +1489,8 @@ class RemoteImageBuild(dict):
             pulumi.set(__self__, "remote_context", remote_context)
         if remove is not None:
             pulumi.set(__self__, "remove", remove)
+        if secrets is not None:
+            pulumi.set(__self__, "secrets", secrets)
         if security_opts is not None:
             pulumi.set(__self__, "security_opts", security_opts)
         if session_id is not None:
@@ -1424,7 +1514,7 @@ class RemoteImageBuild(dict):
     @pulumi.getter
     def context(self) -> builtins.str:
         """
-        Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
+        Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. This always refers to the local working directory, even when building images on remote hosts. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
         """
         return pulumi.get(self, "context")
 
@@ -1436,19 +1526,11 @@ class RemoteImageBuild(dict):
         """
         return pulumi.get(self, "auth_configs")
 
-    @property
-    @pulumi.getter(name="buildArg")
-    def build_arg(self) -> Optional[Mapping[str, builtins.str]]:
-        """
-        Set build-time variables
-        """
-        return pulumi.get(self, "build_arg")
-
     @property
     @pulumi.getter(name="buildArgs")
     def build_args(self) -> Optional[Mapping[str, builtins.str]]:
         """
-        Pairs for build-time variables in the form TODO
+        Pairs for build-time variables in the form of `ENDPOINT : "https://example.com"`
         """
         return pulumi.get(self, "build_args")
 
@@ -1460,6 +1542,22 @@ class RemoteImageBuild(dict):
         """
         return pulumi.get(self, "build_id")
 
+    @property
+    @pulumi.getter(name="buildLogFile")
+    def build_log_file(self) -> Optional[builtins.str]:
+        """
+        Path to a file where the buildx log are written to. Only available when `builder` is set. If not set, no logs are available. The path is taken as is, so make sure to use a path that is available.
+        """
+        return pulumi.get(self, "build_log_file")
+
+    @property
+    @pulumi.getter
+    def builder(self) -> Optional[builtins.str]:
+        """
+        Set the name of the buildx builder to use. If not set or empty, the legacy builder will be used.
+        """
+        return pulumi.get(self, "builder")
+
     @property
     @pulumi.getter(name="cacheFroms")
     def cache_froms(self) -> Optional[Sequence[builtins.str]]:
@@ -1616,7 +1714,7 @@ class RemoteImageBuild(dict):
     @pulumi.getter(name="remoteContext")
     def remote_context(self) -> Optional[builtins.str]:
         """
-        A Git repository URI or HTTP/HTTPS context URI
+        A Git repository URI or HTTP/HTTPS context URI. Will be ignored if `builder` is set.
         """
         return pulumi.get(self, "remote_context")
 
@@ -1628,6 +1726,14 @@ class RemoteImageBuild(dict):
         """
         return pulumi.get(self, "remove")
 
+    @property
+    @pulumi.getter
+    def secrets(self) -> Optional[Sequence['outputs.RemoteImageBuildSecret']]:
+        """
+        Set build-time secrets. Only available when you use a buildx builder.
+        """
+        return pulumi.get(self, "secrets")
+
     @property
     @pulumi.getter(name="securityOpts")
     def security_opts(self) -> Optional[Sequence[builtins.str]]:
@@ -1828,6 +1934,48 @@ class RemoteImageBuildAuthConfig(dict):
         return pulumi.get(self, "user_name")
 
 
+@pulumi.output_type
+class RemoteImageBuildSecret(dict):
+    def __init__(__self__, *,
+                 id: builtins.str,
+                 env: Optional[builtins.str] = None,
+                 src: Optional[builtins.str] = None):
+        """
+        :param builtins.str id: ID of the secret. By default, secrets are mounted to /run/secrets/\\n\\n
+        :param builtins.str env: Environment variable source of the secret
+        :param builtins.str src: File source of the secret. Takes precedence over `env`
+        """
+        pulumi.set(__self__, "id", id)
+        if env is not None:
+            pulumi.set(__self__, "env", env)
+        if src is not None:
+            pulumi.set(__self__, "src", src)
+
+    @property
+    @pulumi.getter
+    def id(self) -> builtins.str:
+        """
+        ID of the secret. By default, secrets are mounted to /run/secrets/\\n\\n
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def env(self) -> Optional[builtins.str]:
+        """
+        Environment variable source of the secret
+        """
+        return pulumi.get(self, "env")
+
+    @property
+    @pulumi.getter
+    def src(self) -> Optional[builtins.str]:
+        """
+        File source of the secret. Takes precedence over `env`
+        """
+        return pulumi.get(self, "src")
+
+
 @pulumi.output_type
 class RemoteImageBuildUlimit(dict):
     def __init__(__self__, *,
@@ -4169,3 +4317,94 @@ class GetNetworkIpamConfigResult(dict):
         return pulumi.get(self, "subnet")
 
 
+@pulumi.output_type
+class GetRegistryImageManifestsAuthConfigResult(dict):
+    def __init__(__self__, *,
+                 address: builtins.str,
+                 password: builtins.str,
+                 username: builtins.str):
+        """
+        :param builtins.str address: The address of the Docker registry.
+        :param builtins.str password: The password for the Docker registry.
+        :param builtins.str username: The username for the Docker registry.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "password", password)
+        pulumi.set(__self__, "username", username)
+
+    @property
+    @pulumi.getter
+    def address(self) -> builtins.str:
+        """
+        The address of the Docker registry.
+        """
+        return pulumi.get(self, "address")
+
+    @property
+    @pulumi.getter
+    def password(self) -> builtins.str:
+        """
+        The password for the Docker registry.
+        """
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter
+    def username(self) -> builtins.str:
+        """
+        The username for the Docker registry.
+        """
+        return pulumi.get(self, "username")
+
+
+@pulumi.output_type
+class GetRegistryImageManifestsManifestResult(dict):
+    def __init__(__self__, *,
+                 architecture: builtins.str,
+                 media_type: builtins.str,
+                 os: builtins.str,
+                 sha256_digest: builtins.str):
+        """
+        :param builtins.str architecture: The platform architecture supported by the manifest.
+        :param builtins.str media_type: The media type of the manifest.
+        :param builtins.str os: The operating system supported by the manifest.
+        :param builtins.str sha256_digest: The content digest of the manifest, as stored in the registry.
+        """
+        pulumi.set(__self__, "architecture", architecture)
+        pulumi.set(__self__, "media_type", media_type)
+        pulumi.set(__self__, "os", os)
+        pulumi.set(__self__, "sha256_digest", sha256_digest)
+
+    @property
+    @pulumi.getter
+    def architecture(self) -> builtins.str:
+        """
+        The platform architecture supported by the manifest.
+        """
+        return pulumi.get(self, "architecture")
+
+    @property
+    @pulumi.getter(name="mediaType")
+    def media_type(self) -> builtins.str:
+        """
+        The media type of the manifest.
+        """
+        return pulumi.get(self, "media_type")
+
+    @property
+    @pulumi.getter
+    def os(self) -> builtins.str:
+        """
+        The operating system supported by the manifest.
+        """
+        return pulumi.get(self, "os")
+
+    @property
+    @pulumi.getter(name="sha256Digest")
+    def sha256_digest(self) -> builtins.str:
+        """
+        The content digest of the manifest, as stored in the registry.
+        """
+        return pulumi.get(self, "sha256_digest")
+
+

pulumi_docker/provider.py

@@ -24,6 +24,8 @@ class ProviderArgs:
                  ca_material: Optional[pulumi.Input[builtins.str]] = None,
                  cert_material: Optional[pulumi.Input[builtins.str]] = None,
                  cert_path: Optional[pulumi.Input[builtins.str]] = None,
+                 context: Optional[pulumi.Input[builtins.str]] = None,
+                 disable_docker_daemon_check: Optional[pulumi.Input[builtins.bool]] = None,
                  host: Optional[pulumi.Input[builtins.str]] = None,
                  key_material: Optional[pulumi.Input[builtins.str]] = None,
                  registry_auth: Optional[pulumi.Input[Sequence[pulumi.Input['ProviderRegistryAuthArgs']]]] = None,
@@ -33,6 +35,10 @@ class ProviderArgs:
         :param pulumi.Input[builtins.str] ca_material: PEM-encoded content of Docker host CA certificate
         :param pulumi.Input[builtins.str] cert_material: PEM-encoded content of Docker client certificate
         :param pulumi.Input[builtins.str] cert_path: Path to directory with Docker TLS config
+        :param pulumi.Input[builtins.str] context: The name of the Docker context to use. Can also be set via `DOCKER_CONTEXT` environment variable. Overrides the `host`
+               if set.
+        :param pulumi.Input[builtins.bool] disable_docker_daemon_check: If set to `true`, the provider will not check if the Docker daemon is running. This is useful for
+               resources/data_sourcess that do not require a running Docker daemon, such as the data source `RegistryImage`.
         :param pulumi.Input[builtins.str] host: The Docker daemon address
         :param pulumi.Input[builtins.str] key_material: PEM-encoded content of Docker client private key
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ssh_opts: Additional SSH option flags to be appended when using `ssh://` protocol
@@ -43,6 +49,10 @@ class ProviderArgs:
             pulumi.set(__self__, "cert_material", cert_material)
         if cert_path is not None:
             pulumi.set(__self__, "cert_path", cert_path)
+        if context is not None:
+            pulumi.set(__self__, "context", context)
+        if disable_docker_daemon_check is not None:
+            pulumi.set(__self__, "disable_docker_daemon_check", disable_docker_daemon_check)
         if host is None:
             host = _utilities.get_env('DOCKER_HOST')
         if host is not None:
@@ -90,6 +100,32 @@ class ProviderArgs:
     def cert_path(self, value: Optional[pulumi.Input[builtins.str]]):
         pulumi.set(self, "cert_path", value)
 
+    @property
+    @pulumi.getter
+    def context(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The name of the Docker context to use. Can also be set via `DOCKER_CONTEXT` environment variable. Overrides the `host`
+        if set.
+        """
+        return pulumi.get(self, "context")
+
+    @context.setter
+    def context(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "context", value)
+
+    @property
+    @pulumi.getter(name="disableDockerDaemonCheck")
+    def disable_docker_daemon_check(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        If set to `true`, the provider will not check if the Docker daemon is running. This is useful for
+        resources/data_sourcess that do not require a running Docker daemon, such as the data source `RegistryImage`.
+        """
+        return pulumi.get(self, "disable_docker_daemon_check")
+
+    @disable_docker_daemon_check.setter
+    def disable_docker_daemon_check(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "disable_docker_daemon_check", value)
+
     @property
     @pulumi.getter
     def host(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -145,6 +181,8 @@ class Provider(pulumi.ProviderResource):
                  ca_material: Optional[pulumi.Input[builtins.str]] = None,
                  cert_material: Optional[pulumi.Input[builtins.str]] = None,
                  cert_path: Optional[pulumi.Input[builtins.str]] = None,
+                 context: Optional[pulumi.Input[builtins.str]] = None,
+                 disable_docker_daemon_check: Optional[pulumi.Input[builtins.bool]] = None,
                  host: Optional[pulumi.Input[builtins.str]] = None,
                  key_material: Optional[pulumi.Input[builtins.str]] = None,
                  registry_auth: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProviderRegistryAuthArgs', 'ProviderRegistryAuthArgsDict']]]]] = None,
@@ -161,6 +199,10 @@ class Provider(pulumi.ProviderResource):
         :param pulumi.Input[builtins.str] ca_material: PEM-encoded content of Docker host CA certificate
         :param pulumi.Input[builtins.str] cert_material: PEM-encoded content of Docker client certificate
         :param pulumi.Input[builtins.str] cert_path: Path to directory with Docker TLS config
+        :param pulumi.Input[builtins.str] context: The name of the Docker context to use. Can also be set via `DOCKER_CONTEXT` environment variable. Overrides the `host`
+               if set.
+        :param pulumi.Input[builtins.bool] disable_docker_daemon_check: If set to `true`, the provider will not check if the Docker daemon is running. This is useful for
+               resources/data_sourcess that do not require a running Docker daemon, such as the data source `RegistryImage`.
         :param pulumi.Input[builtins.str] host: The Docker daemon address
         :param pulumi.Input[builtins.str] key_material: PEM-encoded content of Docker client private key
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ssh_opts: Additional SSH option flags to be appended when using `ssh://` protocol
@@ -195,6 +237,8 @@ class Provider(pulumi.ProviderResource):
                  ca_material: Optional[pulumi.Input[builtins.str]] = None,
                  cert_material: Optional[pulumi.Input[builtins.str]] = None,
                  cert_path: Optional[pulumi.Input[builtins.str]] = None,
+                 context: Optional[pulumi.Input[builtins.str]] = None,
+                 disable_docker_daemon_check: Optional[pulumi.Input[builtins.bool]] = None,
                  host: Optional[pulumi.Input[builtins.str]] = None,
                  key_material: Optional[pulumi.Input[builtins.str]] = None,
                  registry_auth: Optional[pulumi.Input[Sequence[pulumi.Input[Union['ProviderRegistryAuthArgs', 'ProviderRegistryAuthArgsDict']]]]] = None,
@@ -211,6 +255,8 @@ class Provider(pulumi.ProviderResource):
             __props__.__dict__["ca_material"] = ca_material
             __props__.__dict__["cert_material"] = cert_material
             __props__.__dict__["cert_path"] = cert_path
+            __props__.__dict__["context"] = context
+            __props__.__dict__["disable_docker_daemon_check"] = pulumi.Output.from_input(disable_docker_daemon_check).apply(pulumi.runtime.to_json) if disable_docker_daemon_check is not None else None
             if host is None:
                 host = _utilities.get_env('DOCKER_HOST')
             __props__.__dict__["host"] = host
@@ -247,6 +293,15 @@ class Provider(pulumi.ProviderResource):
         """
         return pulumi.get(self, "cert_path")
 
+    @property
+    @pulumi.getter
+    def context(self) -> pulumi.Output[Optional[builtins.str]]:
+        """
+        The name of the Docker context to use. Can also be set via `DOCKER_CONTEXT` environment variable. Overrides the `host`
+        if set.
+        """
+        return pulumi.get(self, "context")
+
     @property
     @pulumi.getter
     def host(self) -> pulumi.Output[Optional[builtins.str]]:

pulumi_docker/pulumi-plugin.json

@@ -1,5 +1,5 @@
 {
   "resource": true,
   "name": "docker",
-  "version": "4.7.0-alpha.1747374653"
+  "version": "4.7.0-alpha.1747852246"
 }