com.github.dockerjava.core.DefaultDockerClientConfig Java Examples

@Test
public void whenCreatingDockerClientWithProperties_thenReturnInstance() {

    // when
    Properties properties = new Properties();
    properties.setProperty("registry.email", "[email protected]");
    properties.setProperty("registry.url", "register.bealdung.io/v2/");
    properties.setProperty("registry.password", "strongpassword");
    properties.setProperty("registry.username", "bealdung");
    properties.setProperty("DOCKER_CERT_PATH", "/home/bealdung/public/.docker/certs");
    properties.setProperty("DOCKER_CONFIG", "/home/bealdung/public/.docker/");
    properties.setProperty("DOCKER_TLS_VERIFY", "1");
    properties.setProperty("DOCKER_HOST", "tcp://docker.bealdung.com:2376");

    DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().withProperties(properties).build();

    DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();

    // then
    assertNotNull(dockerClient);
}
 

/**
 * Instantiates a new Docker opt.
 *
 * @param log              日志对象
 * @param host             DOCKER_HOST, e.g. tcp://10.200.131.182:2375
 * @param registryUrl      registry地址， e.g. https://harbor.dew.env/v2
 * @param registryUsername registry用户名
 * @param registryPassword registry密码
 * @see <a href="https://docs.docker.com/install/linux/linux-postinstall/#configure-where-the-docker-daemon-listens-for-connections">The Docker Daemon Listens For Connections</a>
 */
protected DockerOpt(Logger log, String host, String registryUrl, String registryUsername, String registryPassword) {
    this.log = log;
    this.registryUsername = registryUsername;
    this.registryPassword = registryPassword;
    DefaultDockerClientConfig.Builder builder = DefaultDockerClientConfig.createDefaultConfigBuilder();
    if (host != null && !host.isEmpty()) {
        builder.withDockerHost(host);
    }
    if (registryUrl != null) {
        registryUrl = registryUrl.endsWith("/") ? registryUrl.substring(0, registryUrl.length() - 1) : registryUrl;
        registryApiUrl = registryUrl.substring(0, registryUrl.lastIndexOf("/") + 1) + "api/v2.0";
        defaultAuthConfig = new AuthConfig()
                .withRegistryAddress(registryUrl)
                .withUsername(registryUsername)
                .withPassword(registryPassword);
    }
    docker = DockerClientBuilder.getInstance(builder.build()).build();
}
 

public DockerClient getDockerClient(String registryUsername,
                                    String registryPassword,
                                    String registryEmail,
                                    String dockerCertPath,
                                    String dockerConfig,
                                    String dockerTlsVerify,
                                    String dockerHost) {
    DefaultDockerClientConfig config
            = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withRegistryEmail(registryEmail)
            .withRegistryPassword(registryPassword)
            .withRegistryUsername(registryUsername)
            .withDockerCertPath(dockerCertPath)
            .withDockerConfig(dockerConfig)
            .withDockerTlsVerify(dockerTlsVerify)
            .withDockerHost(dockerHost).build();

    return DockerClientBuilder.getInstance(config).build();
}
 

@NotNull
protected DockerClientConfig tryConfiguration(String dockerHost) {

    Path dockerSocketFile = Paths.get(DOCKER_SOCK_PATH);
    Integer mode;
    try {
        mode = (Integer) Files.getAttribute(dockerSocketFile, "unix:mode");
    } catch (IOException e) {
        throw new InvalidConfigurationException("Could not find unix domain socket", e);
    }

    if ((mode & 0xc000) != SOCKET_FILE_MODE_MASK) {
        throw new InvalidConfigurationException("Found docker unix domain socket but file mode was not as expected (expected: srwxr-xr-x). This problem is possibly due to occurrence of this issue in the past: https://github.com/docker/docker/issues/13121");
    }

    config = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(dockerHost)
            .withDockerTlsVerify(false)
            .build();
    client = getClientForConfig(config);

    final int timeout = Integer.parseInt(System.getProperty(PING_TIMEOUT_PROPERTY_NAME, PING_TIMEOUT_DEFAULT));
    ping(client, timeout);

    return config;
}
 

/**
 * Initialize the docker client. 
 * 
 * @return an error message if there were issues, <code>null</code> if everyhtin gwent smooth.
 */
public String initDocker() {
    try {
        DefaultDockerClientConfig.Builder builder = DefaultDockerClientConfig.createDefaultConfigBuilder();
        if (OsCheck.getOperatingSystemType() == OSType.Windows) {
            builder.withDockerHost("tcp://localhost:2375");
        }
        dockerClient = DockerClientBuilder.getInstance(builder).build();

        dockerClient.versionCmd().exec();
    } catch (Exception e) {
        String msg = MSG_NOTRUNNING;
        if (OsCheck.getOperatingSystemType() == OSType.Windows) {
            msg += "\n" + MSG_WIN_SOCKET;
        }
        return msg;
    }

    return null;
}
 

/**
 * Creates a Docker client from target properties.
 * @param targetProperties a non-null map
 * @return a Docker client
 * @throws TargetException if something went wrong
 */
public static DockerClient createDockerClient( Map<String,String> targetProperties ) throws TargetException {

	// Validate what needs to be validated.
	Logger logger = Logger.getLogger( DockerHandler.class.getName());
	logger.fine( "Setting the target properties." );

	String edpt = targetProperties.get( DockerHandler.ENDPOINT );
	if( Utils.isEmptyOrWhitespaces( edpt ))
		edpt = DockerHandler.DEFAULT_ENDPOINT;

	// The configuration is straight-forward.
	Builder config =
			DefaultDockerClientConfig.createDefaultConfigBuilder()
			.withDockerHost( edpt )
			.withRegistryUsername( targetProperties.get( DockerHandler.USER ))
			.withRegistryPassword( targetProperties.get( DockerHandler.PASSWORD ))
			.withRegistryEmail( targetProperties.get( DockerHandler.EMAIL ))
			.withApiVersion( targetProperties.get( DockerHandler.VERSION ));

	// Build the client.
	DockerClientBuilder clientBuilder = DockerClientBuilder.getInstance( config.build());

	return clientBuilder.build();
}
 

@Test
public void testNettyDockerCmdExecFactoryConfigWithoutApiVersion() throws Exception {
    int dockerPort = getFreePort();

    NettyDockerCmdExecFactory factory = new NettyDockerCmdExecFactory();
    Builder configBuilder = new DefaultDockerClientConfig.Builder()
        .withDockerTlsVerify(false)
        .withDockerHost("tcp://localhost:" + dockerPort);

    DockerClient client = DockerClientBuilder.getInstance(configBuilder)
        .withDockerCmdExecFactory(factory)
        .build();

    FakeDockerServer server = new FakeDockerServer(dockerPort);
    server.start();
    try {
        client.versionCmd().exec();

        List<HttpRequest> requests = server.getRequests();

        assertEquals(requests.size(), 1);
        assertEquals(requests.get(0).uri(), "/version");
    } finally {
        server.stop();
    }
}
 

/**
 * 更高级的连接方式，后续使用证书需要用到
 *
 * @return
 */
public static DockerClient advanceConnect() {
    DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost("tcp://localhost:2376")
            //TODO 后续支持证书
            .withDockerTlsVerify(true)
            .withDockerCertPath("/home/user/.docker/certs")//证书？
            .withDockerConfig("/Users/vjay/.docker")
            .withApiVersion("1.30") // optional
            .withRegistryUrl("https://index.docker.io/v1/")//填私库地址
            .withRegistryUsername("username")//填私库用户名
            .withRegistryPassword("123456")//填私库密码
            .withRegistryEmail("[email protected]")//填私库注册邮箱
            .build();
    return DockerClientBuilder.getInstance(config).build();
}
 

@Deprecated
public JsonStreamProcessor(Class<T> clazz) {
    this(
            DefaultDockerClientConfig.createDefaultConfigBuilder().build().getObjectMapper(),
            new TypeReference<T>() {
            }
    );
}
 

@Deprecated
public NettyInvocationBuilder(ChannelProvider channelProvider, String resource) {
    this(
            DefaultDockerClientConfig.createDefaultConfigBuilder().build().getObjectMapper(),
            channelProvider,
            resource
    );
}
 

@Deprecated
public NettyWebTarget(ChannelProvider channelProvider, String host) {
    this(
            DefaultDockerClientConfig.createDefaultConfigBuilder().build().getObjectMapper(),
            channelProvider,
            host,
            ImmutableList.of(),
            ImmutableMap.of(),
            ImmutableMap.of()
    );
}
 

@Test
public void testNettyDockerCmdExecFactoryConfigWithApiVersion() throws Exception {
    int dockerPort = getFreePort();

    NettyDockerCmdExecFactory factory = new NettyDockerCmdExecFactory();
    Builder configBuilder = new DefaultDockerClientConfig.Builder()
        .withDockerTlsVerify(false)
        .withDockerHost("tcp://localhost:" + dockerPort)
        .withApiVersion("1.23");

    DockerClient client = DockerClientBuilder.getInstance(configBuilder)
            .withDockerCmdExecFactory(factory)
            .build();

    FakeDockerServer server = new FakeDockerServer(dockerPort);
    server.start();
    try {
        client.versionCmd().exec();

        List<HttpRequest> requests = server.getRequests();

        assertEquals(requests.size(), 1);
        assertEquals(requests.get(0).uri(), "/v1.23/version");
    } finally {
        server.stop();
    }
}
 

@Deprecated
public JsonResponseCallbackHandler(TypeReference<T> typeReference, ResultCallback<T> callback) {
    this(
            DefaultDockerClientConfig.createDefaultConfigBuilder().build().getObjectMapper(),
            typeReference,
            callback
    );
}
 

/**
 * Creates a new {@link DockerClient}.
 * It's the caller's responsibility to dispose of the result.
 */
@SuppressWarnings("resource")
private static SharableDockerClient makeClient(final String dockerUri, final String credentialsId,
        final Integer readTimeoutInMillisecondsOrNull, final Integer connectTimeoutInMillisecondsOrNull) {
    NettyDockerCmdExecFactory cmdExecFactory = null;
    DockerClient actualClient = null;
    try {
        cmdExecFactory = new NettyDockerCmdExecFactory()
                .withReadTimeout(readTimeoutInMillisecondsOrNull)
                .withConnectTimeout(connectTimeoutInMillisecondsOrNull);
        final DefaultDockerClientConfig.Builder configBuilder = new DefaultDockerClientConfig.Builder()
                .withDockerHost(dockerUri)
                .withCustomSslConfig(toSSlConfig(credentialsId));
        actualClient = DockerClientBuilder.getInstance(configBuilder)
            .withDockerCmdExecFactory(cmdExecFactory)
            .build();
        final SharableDockerClient multiUsageClient = new SharableDockerClient(actualClient);
        // if we've got this far, we're going to succeed, so we need to ensure that we
        // don't close the resources we're returning.
        cmdExecFactory = null;
        actualClient = null;
        return multiUsageClient;
    } finally {
        // these will no-op if we're successfully returning a value, but in any error
        // cases we should ensure that we don't leak precious resources.
        closeAndLogAnyExceptions(cmdExecFactory);
        closeAndLogAnyExceptions(actualClient);
    }
}
 

@NotNull
private DockerClientConfig tryConfiguration() {
    config = new DelegatingDockerClientConfig(
        DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(SOCKET_LOCATION)
            .withDockerTlsVerify(false)
            .build()
    );
    client = getClientForConfig(config);

    final int timeout = Integer.parseInt(System.getProperty(PING_TIMEOUT_PROPERTY_NAME, PING_TIMEOUT_DEFAULT));
    ping(client, timeout);

    return config;
}
 

@Test
public void whenCreatingDockerClient_thenReturnDefaultInstance() {

    // when
    DefaultDockerClientConfig.Builder config = DefaultDockerClientConfig.createDefaultConfigBuilder();
    DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();

    // then
    assertNotNull(dockerClient);
}
 

@Test
public void whenCreatingAdvanceDockerClient_thenReturnInstance() {

    // when
    DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().withRegistryEmail("[email protected]").withRegistryUrl("register.bealdung.io/v2/").withRegistryPassword("strongpassword").withRegistryUsername("bealdung")
            .withDockerCertPath("/home/bealdung/public/.docker/certs").withDockerConfig("/home/bealdung/public/.docker/").withDockerTlsVerify("1").withDockerHost("tcp://docker.beauldung.com:2376").build();

    DockerClient dockerClient = DockerClientBuilder.getInstance(config).build();

    // then
    assertNotNull(dockerClient);
}
 

@NotNull
protected DockerClientConfig tryConfiguration(String dockerHost) {
    config = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(dockerHost)
            .withDockerTlsVerify(false)
            .build();
    client = getClientForConfig(config);

    final int timeout = Integer.getInteger(PING_TIMEOUT_PROPERTY_NAME, PING_TIMEOUT_DEFAULT);
    ping(client, timeout);

    return config;
}
 

@Override
public void test() throws InvalidConfigurationException {

    try {
        boolean installed = DockerMachineClient.instance().isInstalled();
        checkArgument(installed, "docker-machine executable was not found on PATH (" + Arrays.toString(CommandLine.getSystemPath()) + ")");

        Optional<String> machineNameOptional = DockerMachineClient.instance().getDefaultMachine();
        checkArgument(machineNameOptional.isPresent(), "docker-machine is installed but no default machine could be found");
        String machineName = machineNameOptional.get();

        log.info("Found docker-machine, and will use machine named {}", machineName);

        DockerMachineClient.instance().ensureMachineRunning(machineName);

        String dockerDaemonIpAddress = DockerMachineClient.instance().getDockerDaemonIpAddress(machineName);

        log.info("Docker daemon IP address for docker machine {} is {}", machineName, dockerDaemonIpAddress);

        config = DefaultDockerClientConfig.createDefaultConfigBuilder()
                .withDockerHost("tcp://" + dockerDaemonIpAddress + ":2376")
                .withDockerTlsVerify(true)
                .withDockerCertPath(Paths.get(System.getProperty("user.home") + "/.docker/machine/certs/").toString())
                .build();
        client = getClientForConfig(config);
    } catch (Exception e) {
        throw new InvalidConfigurationException(e.getMessage());
    }

    // If the docker-machine VM has started, the docker daemon may still not be ready. Retry pinging until it works.
    final int timeout = Integer.parseInt(System.getProperty(PING_TIMEOUT_PROPERTY_NAME, PING_TIMEOUT_DEFAULT));
    ping(client, timeout);
}
 

public static DockerClient build() {
    if (dockerClient == null) {
        DefaultDockerClientConfig.Builder builder = new DefaultDockerClientConfig.Builder();
        builder = builder.withApiVersion("1.12");

        String dockerHostEnv = System.getenv("DOCKER_HOST");
        if (StringUtils.isBlank(dockerHostEnv)) {
            builder.withDockerHost("unix:///var/run/docker.sock");
        }

        DockerClientConfig config = builder.build();
        dockerClient = DockerClientBuilder.getInstance(config).build();
    }
    return dockerClient;
}
 

private static DockerClient createDockerClient() {
    JerseyDockerCmdExecFactory dockerFactory = new JerseyDockerCmdExecFactory()
            .withMaxPerRouteConnections(10)
            .withMaxTotalConnections(100)
            .withConnectTimeout((int) Duration.ofSeconds(100).toMillis())
            .withReadTimeout((int) Duration.ofMinutes(30).toMillis());

    DockerClientConfig dockerClientConfig = new DefaultDockerClientConfig.Builder()
            .withDockerHost("unix:///var/run/docker.sock")
            .build();

    return DockerClientImpl.getInstance(dockerClientConfig)
            .withDockerCmdExecFactory(dockerFactory);
}
 

@BeforeEach
public void init() {
  String dockerHost = (OVERRIDDEN_DOCKER_HOST != null) ? OVERRIDDEN_DOCKER_HOST : DEFAULT_DOCKER_HOST;
  // Assuming insecure docker engine
  DockerClientConfig config =
      DefaultDockerClientConfig.createDefaultConfigBuilder().withDockerHost(dockerHost).build();
  // using jaxrs/jersey implementation here (netty impl is also available)
  DockerCmdExecFactory dockerCmdExecFactory = new JerseyDockerCmdExecFactory().withConnectTimeout(1000)
      .withMaxTotalConnections(100).withMaxPerRouteConnections(10);
  dockerClient = DockerClientBuilder.getInstance(config).withDockerCmdExecFactory(dockerCmdExecFactory).build();
  await().atMost(60, SECONDS).until(this::servicesUp);
}
 

private DockerClient createDockerClient(final DefaultDockerClientConfig config) {
  final DockerCmdExecFactory dockerCmdExecFactory =
      new JerseyDockerCmdExecFactory()
          .withMaxTotalConnections(100)
          .withMaxPerRouteConnections(10)
          .withReadTimeout(7500)
          .withConnectTimeout(7500);

  return DockerClientBuilder.getInstance(config)
      .withDockerCmdExecFactory(dockerCmdExecFactory)
      .build();
}
 

@Bean
public DockerClient dockerClient() {
    String dockerHost = "unix:///var/run/docker.sock";

    DefaultDockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(dockerHost).build();

    return DockerClientBuilder.getInstance(config).build();
}
 

@Before
public void init() throws Exception {
    SocketInitContext context = new SocketInitContext();

    DefaultDockerClientConfig config = DefaultDockerClientConfig
            .createDefaultConfigBuilder()
            .withDockerHost("unix:///var/run/docker.sock")
            .build();
    context.setClient(DockerClientBuilder.getInstance(config).build());
    manager.init(context);
}
 

/**
 * Creates a DockerClientConfig object to be used when creating the Java Docker client using an unsecured connection.
 * @param host - Docker host address (IP) to connect to
 * @param registryServerUrl - address of the private container registry
 * @param username - user name to connect with to the private container registry
 * @param password - password to connect with to the private container registry
 * @return an instance of DockerClient configuration
 */
public static DockerClientConfig createDockerClientConfig(String host, String registryServerUrl, String username, String password) {
    return DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(host)
            .withDockerTlsVerify(false)
            .withRegistryUrl(registryServerUrl)
            .withRegistryUsername(username)
            .withRegistryPassword(password)
            .build();
}
 

/**
 * Creates a DockerClientConfig object to be used when creating the Java Docker client using a secured connection.
 * @param host - Docker host address (IP) to connect to
 * @param registryServerUrl - address of the private container registry
 * @param username - user name to connect with to the private container registry
 * @param password - password to connect with to the private container registry
 * @param caPemContent - content of the ca.pem certificate file
 * @param keyPemContent - content of the key.pem certificate file
 * @param certPemContent - content of the cert.pem certificate file
 * @return an instance of DockerClient configuration
 */
public static DockerClientConfig createDockerClientConfig(String host, String registryServerUrl, String username, String password,
                                                          String caPemContent, String keyPemContent, String certPemContent) {
    return DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(host)
            .withDockerTlsVerify(true)
            .withCustomSslConfig(new DockerSSLConfig(caPemContent, keyPemContent, certPemContent))
            .withRegistryUrl(registryServerUrl)
            .withRegistryUsername(username)
            .withRegistryPassword(password)
            .build();
}
 

public DockerClient getDockerClient(String serverURL,
                                    String certPath) {
    DefaultDockerClientConfig config
            = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(serverURL).withDockerCertPath(certPath).build();
    return DockerClientBuilder.getInstance(config).build();
}
 

/**
 * Get docker client
 *
 * @param ip
 * @return
 */
public DockerClient getDockerClient(String ip) {
    DefaultDockerClientConfig.Builder builder = DefaultDockerClientConfig.createDefaultConfigBuilder()
            .withDockerHost(String.format(dockerHost, ip));
    DefaultDockerClientConfig config = builder.build();
    DockerClient dockerClient = DockerClientBuilder.getInstance(config).withDockerCmdExecFactory(dockerCmdExecFactory).build();
    return dockerClient;
}
 

/**
 * builds the DockerClientConfig based on Gaia's settings
 * @param settings Gaia's settings
 * @return a docker client configuration
 */
@Bean
DockerClientConfig dockerClientConfig(Settings settings) {
    return DefaultDockerClientConfig.createDefaultConfigBuilder()
        .withDockerHost(settings.getDockerDaemonUrl())
        .build();
}