private async Task <string> CreateContainer(CancellationToken cancellationToken)
{
var portBindings = _ports.ToDictionary(
pair => $"{pair.Key}/tcp",
pair => (IList <PortBinding>) new List <PortBinding>
{
new PortBinding
{
HostPort = pair.Value.ToString()
}
});
var createContainerParameters = new CreateContainerParameters
{
Image = ImageWithTag,
Name = ContainerName,
Tty = true,
Env = Env,
HostConfig = new HostConfig
{
PortBindings = portBindings
}
};
var container = await _dockerClient.Containers.CreateContainerAsync(
createContainerParameters,
cancellationToken).ConfigureAwait(false);
return(container.ID);
}
static void InjectConfig(CreateContainerParameters createContainerParameters, IModuleIdentity identity, bool injectForEdgeHub, IConfigSource configSource)
{
var envVars = new List <string>();
// Inject the connection string as an environment variable
if (identity.Credentials is ConnectionStringCredentials creds && !string.IsNullOrWhiteSpace(creds.ConnectionString))
{
string connectionStringKey = injectForEdgeHub ? Constants.IotHubConnectionStringKey : Constants.EdgeHubConnectionStringKey;
envVars.Add($"{connectionStringKey}={creds.ConnectionString}");
}
if (injectForEdgeHub)
{
envVars.Add($"{Logger.RuntimeLogLevelEnvKey}={Logger.GetLogLevel()}");
}
configSource.Configuration.GetValue <string>(Constants.UpstreamProtocolKey).ToUpstreamProtocol().ForEach(
u =>
{
if (createContainerParameters.Env?.Any(e => e.StartsWith("UpstreamProtocol=", StringComparison.OrdinalIgnoreCase)) == false)
{
envVars.Add($"UpstreamProtocol={u}");
}
});
InjectEnvVars(createContainerParameters, envVars);
}
public void TestGetCreateOptions(string createOptions, CreateContainerParameters expectedCreateOptions)
{
CreateContainerParameters createContainerParameters = DockerConfig.GetCreateOptions(createOptions);
Assert.NotNull(createContainerParameters);
Assert.True(DockerConfig.CompareCreateOptions(expectedCreateOptions, createContainerParameters));
}
public async Task <bool> InstantiateDeployWorkerContainer(Configuration configuration, CancellationToken cancellationToken)
{
logger.Information("---- Starting Deploy Deploy Worker Container ----");
await DownloadImage(KubernoxDeployWorkerImageName, "latest", cancellationToken);
var createParameters = new CreateContainerParameters()
{
Image = "kubernox/kubernox-deploy-worker:latest",
Name = KubernoxDeployWorkerContainerName,
Hostname = KubernoxDeployWorkerContainerName,
Env = new List <string>()
{
$"Proxmox__APIUser={configuration.Proxmox.Username}@{configuration.Proxmox.AuthType}",
$"Proxmox__APIPassword={configuration.Proxmox.Password}",
$"Proxmox__APIUrl={configuration.Proxmox.Host}/api2/json",
$"RabbitMq__Url=amqp://{configuration.Rabbitmq.Username}:{configuration.Rabbitmq.Password}@127.0.0.1:{configuration.Rabbitmq.Port}"
},
HostConfig = new HostConfig()
{
NetworkMode = "host",
RestartPolicy = new RestartPolicy()
{
Name = RestartPolicyKind.Always
}
}
};
return(await DeployAndStartAsync(KubernoxDeployWorkerContainerName, createParameters, cancellationToken));
}
public async Task InitVaultContainer()
{
var registryImage = await dockerWrapper.FindImage(repoTag);
using (var client = dockerWrapper.GetClient())
{
var p = new CreateContainerParameters();
p.Image = registryImage.ID;
//p.Volumes = new Dictionary<string, EmptyStruct>();
//p.Volumes.Add("/certs:/certs", new EmptyStruct());
p.ExposedPorts = new Dictionary <string, EmptyStruct>();
p.HostConfig = new HostConfig();
p.HostConfig.CapAdd = new List <string> {
"IPC_LOCK"
};
p.HostConfig.PortBindings = new Dictionary <string, IList <PortBinding> >();
p.HostConfig.PortBindings.Add("8200/tcp", new List <PortBinding> {
new PortBinding()
{
HostIP = "0.0.0.0",
HostPort = "8200"
}
});
p.Env = new List <string>()
{
"VAULT_DEV_ROOT_TOKEN_ID=myroottoken"
};
p.Name = containerName;
var containerResponse = await client.Containers.CreateContainerAsync(p);
var startP = new ContainerStartParameters();
await client.Containers.StartContainerAsync(containerResponse.ID, startP);
}
}
public async Task <bool> InstantiateKubernoxServiceContainer(Configuration configuration, CancellationToken cancellationToken)
{
logger.Information("---- Starting Deploy Kubernox Container ----");
await DownloadImage(KubernoxServiceImageName, cancellationToken);
var ports = new Dictionary <string, EmptyStruct>();
ports.Add("80/tcp", new EmptyStruct());
var createParameters = new CreateContainerParameters()
{
Image = "kubernox/kubernox-service",
Name = ServiceContainerName,
ExposedPorts = ports,
HostConfig = StackHostConfig(),
Hostname = ServiceContainerName,
Env = new List <string>()
{
$"Kubernox__Domain={configuration.Kubernox.Domain}",
$"Proxmox__Uri={configuration.Proxmox.Host}",
$"Proxmox__Token=PVEAPIToken={configuration.Proxmox.Username}@{configuration.Proxmox.AuthType}!{configuration.Proxmox.TokenId}={configuration.Proxmox.AccessToken}",
$"Serilog__WriteTo__1__Args__connectionString=Host={configuration.Postgre.Host};Database={configuration.Postgre.DbName};Username={configuration.Postgre.Username};Password={configuration.Postgre.Password}",
$"ConnectionStrings__Default=Host={configuration.Postgre.Host};Database={configuration.Postgre.DbName};Username={configuration.Postgre.Username};Password={configuration.Postgre.Password}",
$"ConnectionStrings__Redis={configuration.Redis.Host},password={configuration.Redis.Password}",
$"RabbitMq__User={configuration.Rabbitmq.Username}",
$"RabbitMq__Password={configuration.Rabbitmq.Password}",
$"RabbitMq__HostName={configuration.Rabbitmq.Host}",
$"RabbitMq__VirtualHost={configuration.Rabbitmq.Virtualhost}",
$"RabbitMq__Port={configuration.Rabbitmq.Port}"
}
};
return(await DeployAndStartAsync(ServiceContainerName, createParameters, cancellationToken));
}
private async Task <CreateContainerResponse> StartContainer()
{
var createContainerParameters = new CreateContainerParameters
{
Image = "mcr.microsoft.com/dotnet/aspnet",
ExposedPorts = new Dictionary <string, EmptyStruct>
{
{
"8000", default(EmptyStruct)
}
},
HostConfig = new HostConfig
{
PortBindings = new Dictionary <string, IList <PortBinding> >
{
{
"8000", new List <PortBinding> {
new PortBinding {
HostPort = "8000"
}
}
}
}
}
};
return(await _dockerClient.Containers.CreateContainerAsync(createContainerParameters));
}
public async Task <Tuple <string, string> > SpawnContainer()
{
using (var client = GetDockerClient())
{
var port = GetAvailablePort().ToString();
var config = new CreateContainerParameters {
Image = "dockerchromedriver",
HostConfig = new HostConfig {
PortBindings = new Dictionary <string, IList <PortBinding> > {
{ "9515", new List <PortBinding> {
new PortBinding {
HostPort = port
}
} }
}
},
ExposedPorts = new Dictionary <string, EmptyStruct> {
{ "9515", new EmptyStruct() }
}
};
var createResponse = await client.Containers.CreateContainerAsync(config);
await client.Containers.StartContainerAsync(createResponse.ID, new ContainerStartParameters());
return(new Tuple <string, string>(createResponse.ID, port));
}
}
public void RunOne(string image, string ip)
{
var client = _pools.GetPoolByIp(ip).Get();
var p = new CreateContainerParameters
{
Image = image,
Cmd = new string[] { "/bin/bash" },
Tty = true
};
// var p = new CreateContainerParameters
// {
// Image = image,
// Cmd = new string[] {"/bin/bash"},
// Tty = true,
// HostConfig = new HostConfig
// {
// PortBindings = new Dictionary<string, IList<PortBinding>>
// {
// { "5423", new List<PortBinding> { new PortBinding{HostPort = "7799"} } }
// }
// }
// };
var createdContainer = client.Containers.CreateContainerAsync(p).GetAwaiter().GetResult();
client.Containers.StartContainerAsync(createdContainer.ID, new ContainerStartParameters()).GetAwaiter().GetResult();
}
private static async Task <ContainerListResponse> CreateContainer(IDockerClient client)
{
var hostConfig = CreateHostConfig();
var volumeMount = AppDomain.CurrentDomain.BaseDirectory.Replace("\\", "/");
var parameters = new CreateContainerParameters
{
Hostname = "localhost",
Image = ImageName + ":" + ImageTag,
Name = ContainerName,
Tty = false,
HostConfig = hostConfig,
Volumes = new Dictionary <string, EmptyStruct>
{
// TODO: fix hardcode
{ $"{volumeMount}:/home", new EmptyStruct() }
},
ExposedPorts = new Dictionary <string, EmptyStruct>
{
{ Port, new EmptyStruct() }
},
};
var response = await client.Containers.CreateContainerAsync(parameters);
var containers = await client.Containers.ListContainersAsync(new ContainersListParameters { All = true });
var container = containers.First(c => c.ID == response.ID);
return(container);
}
static void InjectLoggerConfig(CreateContainerParameters createContainerParameters, DockerLoggingConfig defaultDockerLoggerConfig, Option <string> sourceLoggingOptions)
{
createContainerParameters.HostConfig = createContainerParameters.HostConfig ?? new HostConfig();
Option <LogConfig> sourceOptions;
try
{
sourceOptions = sourceLoggingOptions.Filter(l => !string.IsNullOrEmpty(l)).Map(
l =>
JsonConvert.DeserializeObject <LogConfig>(l));
}
catch
{
sourceOptions = Option.None <LogConfig>();
}
if (createContainerParameters.HostConfig.LogConfig == null || string.IsNullOrWhiteSpace(createContainerParameters.HostConfig.LogConfig.Type))
{
createContainerParameters.HostConfig.LogConfig = sourceOptions.GetOrElse(
new LogConfig
{
Type = defaultDockerLoggerConfig.Type,
Config = defaultDockerLoggerConfig.Config
});
}
}
/// <summary>
/// Creates a new container by copying data, and deleting, an existing container.
/// </summary>
/// <param name="id">Id of the container to rebuild.</param>
/// <returns>The new id for the container.</returns>
public async Task <string> RebuildContainerAsync(string id)
{
// save the current container, we'll copy over data when creating the new one
var container = await GetContainerAsync(id);
// delete container using DockerService as to not delete it's directory as well
await _dockerService.DeleteContainerWithIdAsync(id);
// create the new container
var bindingDate = string.IsNullOrEmpty(container.ContainerDirectoryName)
? null
: BindingData(_fileSystemService.GetDirectory(container.ContainerDirectoryName));
var hostConfig = new HostConfig
{
Binds = bindingDate,
PortBindings = PortBindings(_portManagerService.AllocatePort())
};
var createParams = new CreateContainerParameters
{
Name = container.FriendlyName(),
Image = container.Image,
HostConfig = hostConfig
};
var result = await _dockerService.CreateContainer(createParams);
return(result.ID);
}
protected virtual CreateContainerParameters GetCreateContainerParameters(string[] environmentVariables)
{
var createParams = new CreateContainerParameters
{
Name = Name,
Image = $"{ImageName}:{Tag}",
AttachStdout = true,
Env = environmentVariables,
Hostname = Name,
HostConfig = new HostConfig
{
PublishAllPorts = Ports == null
}
};
if (Ports != null)
{
createParams.HostConfig.PortBindings = Ports
.ToDictionary(
p => $"{p.Key}/tcp",
p => (IList <PortBinding>) new List <PortBinding>
{
new PortBinding {
HostPort = p.Value.ToString()
}
});
}
if (Entrypoint != null && Entrypoint.Any())
{
createParams.Entrypoint = Entrypoint;
}
return(createParams);
}
private async Task <string> CreateContainer(CancellationToken cancellationToken)
{
var createContainerParameters = new CreateContainerParameters
{
Image = ImageWithTag,
Name = ContainerName,
Tty = true,
Env = Env,
HostConfig = new HostConfig
{
PortBindings = _ports.ToDictionary(
port => $"{port}/tcp",
port => (IList <PortBinding>) new List <PortBinding>
{
new PortBinding
{
HostPort = port.ToString()
}
})
}
};
var container = await _dockerClient.Containers.CreateContainerAsync(
createContainerParameters,
cancellationToken).NotOnCapturedContext();
return(container.ID);
}
public void CreateContainer()
{
var config = new Config();
var parameters = new CreateContainerParameters(config);
parameters.Name = "nooptime-postgres";
parameters.Env = new List <string>();
parameters.Env.Add("POSTGRES_USER=nooptime");
parameters.Env.Add("POSTGRES_PASSWORD=nooptime");
parameters.ExposedPorts = new Dictionary <string, EmptyStruct>();
parameters.ExposedPorts.Add("5432/tcp", new EmptyStruct());
parameters.Image = "postgres";
parameters.HostConfig = new HostConfig()
{
PublishAllPorts = true,
PortBindings = new Dictionary <string, IList <PortBinding> >()
};
parameters.HostConfig.PortBindings.Add("5432/tcp", new List <PortBinding>()
{
new PortBinding()
{
HostIP = "",
HostPort = "7878/tcp"
}
});
var createresult = _dockerClient.Containers.CreateContainerAsync(parameters).Result;
_containerId = createresult.ID;
}
public async Task <CreateContainerResponse> CreateContainerAsync(CreateContainerParameters parameters)
{
IQueryString qs = null;
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (!string.IsNullOrEmpty(parameters.ContainerName))
{
qs = new QueryString <CreateContainerParameters>(parameters);
}
string path = "containers/create";
JsonRequestContent <Config> data = null;
if (parameters.Config != null)
{
data = new JsonRequestContent <Config>(parameters.Config, this.Client.JsonSerializer);
}
DockerApiResponse response = await this.Client.MakeRequestAsync(new[] { NoSuchContainerHandler }, HttpMethod.Post, path, qs, data).ConfigureAwait(false);
return(this.Client.JsonSerializer.DeserializeObject <CreateContainerResponse>(response.Body));
}
public DockerConfig(string image, string createOptions)
{
this.Image = image?.Trim() ?? string.Empty;
this.createOptions = string.IsNullOrWhiteSpace(createOptions)
? new CreateContainerParameters()
: JsonConvert.DeserializeObject <CreateContainerParameters>(createOptions);
}
void InjectNetworkAliases(IModule module, CreateContainerParameters createOptions)
{
if (createOptions.NetworkingConfig?.EndpointsConfig == null)
{
string networkId = this.configSource.Configuration.GetValue <string>(Constants.NetworkIdKey);
string edgeDeviceHostName = this.configSource.Configuration.GetValue <string>(Constants.EdgeDeviceHostNameKey);
if (!string.IsNullOrWhiteSpace(networkId))
{
var endpointSettings = new EndpointSettings();
if (module.Name.Equals(Constants.EdgeHubModuleName, StringComparison.OrdinalIgnoreCase) &&
!string.IsNullOrWhiteSpace(edgeDeviceHostName))
{
endpointSettings.Aliases = new List <string>
{
edgeDeviceHostName
};
}
IDictionary <string, EndpointSettings> endpointsConfig = new Dictionary <string, EndpointSettings>
{
[networkId] = endpointSettings
};
createOptions.NetworkingConfig = new NetworkingConfig
{
EndpointsConfig = endpointsConfig
};
}
}
}
private async Task <string> RunContainer()
{
var contParams = new CreateContainerParameters
{
Image = _imageName,
HostConfig = new HostConfig
{
AutoRemove = true,
PortBindings = new Dictionary <string, IList <PortBinding> >
{
["1433/tcp"] = new[] { new PortBinding {
HostPort = "1433"
} }
}
},
ExposedPorts = new Dictionary <string, EmptyStruct>
{
["1433/tcp"] = default(EmptyStruct)
}
};
var cont = await _docker.Containers
.CreateContainerAsync(contParams);
await _docker.Containers
.StartContainerAsync(cont.ID, new ContainerStartParameters());
return(cont.ID);
}
public async Task <string> StartContainer(CreateContainerParameters containerParameters, IDockerImageProvider imageProvider, string containerName)
{
using (var dockerClient = this.dockerClientProvider.GetDockerClient())
{
containerParameters.Image = await imageProvider.GetImage(dockerClient);
var containers = await dockerClient.Containers.ListContainersAsync(new ContainersListParameters { All = true });
var existingContainer = containers.SingleOrDefault(c => c.Names.Contains("/" + containerName));
string containerId = null;
if (existingContainer != null)
{
containerId = existingContainer.ID;
if (existingContainer.State == "running")
{
return(containerId);
}
}
if (containerId == null)
{
containerParameters.Name = containerName;
var container = await dockerClient.Containers.CreateContainerAsync(containerParameters);
containerId = container.ID;
}
await dockerClient.Containers.StartContainerAsync(containerId, new ContainerStartParameters());
ContainerHost.Instance.ContainerIds.TryAdd(containerId, dockerClientProvider.DockerUri);
return(containerId);
}
}
public async Task <bool> InstantiateKubernoxServiceContainer(Configuration configuration, CancellationToken cancellationToken)
{
Console.WriteLine("---- Starting Deploy Kubernox Container ----");
await DownloadImage("kubernox/service", cancellationToken);
var createParameters = new CreateContainerParameters()
{
Image = "wetry/kubernox",
Name = CacheContainerName,
Env = new List <string>()
{
$"Proxmox__Uri={configuration.Proxmox.Host}",
$"Proxmox__Token=PVEAPIToken={configuration.Proxmox.Username}@{configuration.Proxmox.AuthType}!{configuration.Proxmox.TokenId}={configuration.Proxmox.AccessToken}",
$"ConnectionStrings__Default=Data Source={configuration.Postgre.Host};Initial Catalog={configuration.Postgre.DbName};User ID={configuration.Postgre.Username};Password={configuration.Postgre.Password}",
$"ConnectionStrings__Redis={configuration.Redis.Host}",
$"RabbitMq__User={configuration.Rabbitmq.Username}",
$"RabbitMq__Password={configuration.Rabbitmq.Password}",
$"RabbitMq__HostName={configuration.Rabbitmq.Host}",
$"RabbitMq__VirtualHost={configuration.Rabbitmq.Virtualhost}",
$"RabbitMq__Port={configuration.Rabbitmq.Port}"
}
};
return(await DeployAndStartAsync(ServiceContainerName, createParameters, cancellationToken));
}
private async Task StartContainer()
{
var containerParams = new CreateContainerParameters
{
Image = dynamodbLocalImage,
ExposedPorts = new Dictionary <string, EmptyStruct>
{
{ "8000", default(EmptyStruct) }
},
HostConfig = new HostConfig
{
PortBindings = new Dictionary <string, IList <PortBinding> >
{
{ "8000", new List <PortBinding> {
new PortBinding {
HostPort = "8000"
}
} }
},
PublishAllPorts = true
},
};
var createContainerResponse = await _dockerClient.Containers.CreateContainerAsync(containerParams);
_containerId = createContainerResponse.ID;
Console.WriteLine($"Container {createContainerResponse.ID} created");
foreach (var warning in createContainerResponse.Warnings)
{
Console.WriteLine(warning);
}
var containerStarted = await _dockerClient.Containers.StartContainerAsync(_containerId, null);
Console.WriteLine($"Container {containerStarted} started");
}
/// <summary>
/// Creates a new MySQL Server container with default configuration.
/// </summary>
/// <param name="name">The name of the container to create.</param>
/// <returns>The ID of the newly created container.</returns>
public async Task <string> CreateNewContainer(string name)
{
var containerDir = _fileSystemService.CreateDirectory();
ConstructUsersFile(containerDir, new[] { User.Default });
var hostConfig = new HostConfig
{
Binds = BindingData(containerDir),
PortBindings = PortBindings(_portManagerService.AllocatePort())
};
var createParams = new CreateContainerParameters
{
Name = name,
Image = ContainerImageName,
HostConfig = hostConfig
};
try
{
var result = await _dockerService.CreateContainer(createParams);
return(result.ID);
}
catch (DockerContainerNotFoundException)
{
// CreateContainer will throw an exception if unable to load the image.
// Pull the image and try again.
await PullMySqlImageAsync();
return(await CreateNewContainer(name));
}
}
CreateContainerParameters IEnsureContainerIsRunningContext.CreateContainer(CreateContainerParameters createContainerParameters)
{
return(new CreateContainerParameters()
{
Name = _containerName,
Image = "postgres:9.6",
Env = new List <string>()
{
$"POSTGRES_USER={ConnectionString.Username}",
$"POSTGRES_PASSWORD={ConnectionString.Password}",
$"POSTGRES_DB={ConnectionString.Database}",
},
HostConfig = new HostConfig()
{
PortBindings = new Dictionary <string, IList <PortBinding> >()
{
{
"5432/tcp",
new List <PortBinding>()
{
new PortBinding()
{
HostPort = ConnectionString.Port.ToString()
}
}
}
}
},
});
}
public async Task <string> RunAsync(ITestcontainersConfiguration configuration, CancellationToken ct = default)
{
var converter = new TestcontainersConfigurationConverter(configuration);
var hostConfig = new HostConfig
{
PortBindings = converter.PortBindings,
Mounts = converter.Mounts,
};
var createParameters = new CreateContainerParameters
{
Image = configuration.Image.FullName,
Name = configuration.Name,
WorkingDir = configuration.WorkingDirectory,
Entrypoint = converter.Entrypoint,
Cmd = converter.Command,
Env = converter.Environments,
Labels = converter.Labels,
ExposedPorts = converter.ExposedPorts,
HostConfig = hostConfig,
};
var id = (await this.Docker.Containers.CreateContainerAsync(createParameters, ct)
.ConfigureAwait(false)).ID;
Logger.LogInformation("Container {id} created", id);
return(id);
}
public CombinedDockerConfig(string image, CreateContainerParameters createOptions, Option <string> digest, Option <AuthConfig> authConfig)
{
this.Image = Preconditions.CheckNonWhiteSpace(image, nameof(image)).Trim();
this.CreateOptions = Preconditions.CheckNotNull(createOptions, nameof(createOptions));
this.Digest = digest;
this.AuthConfig = authConfig;
}
public async Task Start(CancellationToken cancel = default(CancellationToken))
{
var docker = _lzDocker.Value;
var deduced = _lzDeduced.Value;
_contId = await RunContainer();
ServerUri = await GetContainerUri();
await Task.Delay(1500, cancel); //miserably needed till we can poll for readiness
async Task <string> RunContainer()
{
var contParams = new CreateContainerParameters
{
Image = _dockerImage,
HostConfig = new HostConfig
{
AutoRemove = true,
Privileged = true,
Tmpfs = new Dictionary <string, string>
{
["/run"] = "rw"
},
PortBindings = new Dictionary <string, IList <PortBinding> >
{
["1433/tcp"] = new[] { new PortBinding {
HostPort = deduced.HostPorts
} }
}
},
ExposedPorts = new Dictionary <string, EmptyStruct>
{
["1433/tcp"] = default(EmptyStruct)
},
Env = new[] { "STOP_AFTER=1m", "RUN_FAST=1" },
};
var cont = await docker.Containers
.CreateContainerAsync(contParams, cancel);
await docker.Containers
.StartContainerAsync(cont.ID, new ContainerStartParameters(), cancel);
return(cont.ID);
}
async Task <Uri> GetContainerUri()
{
var info = await docker.Containers.InspectContainerAsync(_contId, cancel);
var net = info.NetworkSettings;
var uri = new UriBuilder(deduced.HostUri);
uri.Port = int.Parse(net.Ports["1433/tcp"].First().HostPort);
return(uri.Uri);
}
}
/// <summary>
/// Add image
/// </summary>
/// <param name="deployment"></param>
/// <param name="name"></param>
/// <param name="imageName"></param>
/// <param name="version"></param>
/// <param name="createOptions"></param>
/// <param name="properties"></param>
/// <returns></returns>
public static IEdgeDeployment WithModule(this IEdgeDeployment deployment,
string name, string imageName, System.Version version,
CreateContainerParameters createOptions,
Dictionary <string, dynamic> properties)
{
return(deployment.WithModule(name, imageName, version, createOptions,
ModuleRestartPolicy.Always, properties));
}
/// <summary>
/// Garante a criação e inicialização de um determinado container.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public async Task <string> EnsureCreateAndStartContainer(CreateContainerParameters parameters)
{
var id = await CreateContainerAsync(parameters);
await StartContainerAsync(id);
return(id);
}
/// <summary>
/// Cria o container baseado nos <paramref name="parameters"/>.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public async Task <string> CreateContainerAsync(CreateContainerParameters parameters)
{
var container = await _dockerClient
.Containers
.CreateContainerAsync(parameters);
return(container.ID);
}
