springboot使用docker-java连接docker所在的服务器操作docker

1.添加依赖，docker-java-core那个应该不用

        
            com.github.docker-java
            docker-java
			${docker.version}
            
                
                
                    io.netty
                    *
                
            
        
		
			com.github.docker-java
			docker-java-core
			${docker.version}
		
		
			com.github.docker-java
			docker-java-transport-httpclient5
			${docker.version}
		
		

其中版本控制

		3.2.11

2.添加配置文件docker-java.properties，其他的配置可以按需添加

DOCKER_HOST=tcp://xxx.xx.xx.xx:2375
registry.url=https://xxxxxxxx/
registry.username=xxxxxx
registry.password=xxxxxxx

追踪DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().build();

3.业务类

import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.async.ResultCallback;
import com.github.dockerjava.api.command.*;
import com.github.dockerjava.api.exception.ConflictException;
import com.github.dockerjava.api.exception.DockerClientException;
import com.github.dockerjava.api.exception.InternalServerErrorException;
import com.github.dockerjava.api.exception.NotFoundException;
import com.github.dockerjava.api.model.*;
import com.github.dockerjava.core.DefaultDockerClientConfig;
import com.github.dockerjava.core.DockerClientConfig;
import com.github.dockerjava.core.DockerClientImpl;
import com.github.dockerjava.core.command.ExecStartResultCallback;
import com.github.dockerjava.core.command.PullImageResultCallback;
import com.github.dockerjava.core.command.PushImageResultCallback;
import com.github.dockerjava.httpclient5.ApacheDockerHttpClient;
import com.github.dockerjava.transport.DockerHttpClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;


/**
 * 本地docker管理类
 */
@Service
public class LocalDockerManager {

    private static final Logger log = LoggerFactory.getLogger(DockerManager.class);

    private DockerClient dockerClient;

    public LocalDockerManager() {
        this.init();
    }

    @Override
    /**
     * 初始化dockerClient
     */
    public DockerManager init() {
        DockerClientConfig config = DefaultDockerClientConfig.createDefaultConfigBuilder().build();
        DockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()
                .dockerHost(config.getDockerHost())
                .sslConfig(config.getSSLConfig())
                .build();
        this.dockerClient = DockerClientImpl.getInstance(config, httpClient);
        return this;
    }

    /**
     * 拉取docker镜像
     *
     * @param image
     * @param secondsOfWait
     * @throws Exception
     */
    public void downloadDockerImage(String image, int secondsOfWait) throws InterruptedException {
            // 拉取镜像
            this.dockerClient.pullImageCmd(image).exec(new PullImageResultCallback()).awaitCompletion(secondsOfWait,
                    TimeUnit.SECONDS);
            log.info("Pull Docker image '{}' success", image);
    }

    /**
     * docker镜像是否本地已存在
     *
     * @param image
     * @return
     * @throws ProcessingException
     */
    public boolean dockerImageExistsLocally(String image) throws ProcessingException {
        boolean imageExists = false;
        try {
            this.dockerClient.inspectImageCmd(image).exec();
            imageExists = true;
        } catch (NotFoundException nfe) {
            imageExists = false;
        } catch (ProcessingException e) {
            throw e;
        }
        return imageExists;
    }

    /**
     * 通过本地是否存在hello-world镜像判断docker是否已经安装且可用
     *
     * @throws
     */
    public void checkDockerEnabled() {
        try {
            this.dockerImageExistsLocally("hello-world");
            log.info("Docker is installed and enabled");
        } catch (ProcessingException exception) {
            exception.printStackTrace();
//			throw new 
        }
    }

    @Override
    /**
     *  创建并运行容器
     */
    public String runContainer(String image, String containerName, String user,
                               List<Volume> volumes, List<Bind> binds, String networkMode, List<String> envs, List<String> command,
                               Long shmSize, boolean privileged, Map<String, String> labels) throws Exception {

        CreateContainerCmd cmd = dockerClient.createContainerCmd(image).withEnv(envs);
        if (containerName != null) {
            cmd.withName(containerName);
        }

        if (user != null) {
            cmd.withUser(user);
        }

        HostConfig hostConfig = new HostConfig().withNetworkMode(networkMode).withPrivileged(privileged);
        if (shmSize != null) {
            hostConfig.withShmSize(shmSize);
        }
        if (volumes != null) {
            cmd.withVolumes(volumes);
        }
        if (binds != null) {
            hostConfig.withBinds(binds);
        }

        if (labels != null) {
            cmd.withLabels(labels);
        }

        if (command != null) {
            cmd.withCmd(command);
        }

        cmd.withHostConfig(hostConfig);

        CreateContainerResponse response = null;
        try {
            response = cmd.exec();
            dockerClient.startContainerCmd(response.getId()).exec();
            log.info("Container ID: {}", response.getId());
            return response.getId();
        } catch (ConflictException e) {
            log.error(
                    "The container name {} is already in use. Probably caused by a session with unique publisher re-publishing a stream",
                    containerName);
            throw e;
        } catch (NotFoundException e) {
            log.error("Docker image {} couldn't be found in docker host", image);
            throw e;
        }
    }

    @Override
    /**
     * 删除容器
     */
    public void removeContainer(String containerId, boolean force) {
        dockerClient.removeContainerCmd(containerId).withForce(force).exec();
    }

    /**
     * 强制删除以xxx开始的容器
     *
     * @param imageName
     */
    public void cleanStrandedContainers(String imageName) {
        List<Container> existingContainers = this.dockerClient.listContainersCmd().withShowAll(true).exec();
        for (Container container : existingContainers) {
            if (container.getImage().startsWith(imageName)) {
                log.info("Stranded {} Docker container ({}) removed on startup", imageName, container.getId());
                this.dockerClient.removeContainerCmd(container.getId()).withForce(true).exec();
            }
        }
    }

    /**
     * 得到运行中的container
     *
     * @param fullImageName
     * @return
     */
    public List<String> getRunningContainers(String fullImageName) {
        List<String> containerIds = new ArrayList<>();
        List<Container> existingContainers = this.dockerClient.listContainersCmd().exec();
        for (Container container : existingContainers) {
            if (container.getImage().startsWith(fullImageName)) {
                containerIds.add(container.getId());
            } else if (container.getImageId().contains(fullImageName)) {
                containerIds.add(container.getId());
            }
        }
        return containerIds;
    }

    /**
     * 得到imageId
     *
     * @param fullImageName
     * @return
     */
    public String getImageId(String fullImageName) {
        InspectImageResponse imageResponse = this.dockerClient.inspectImageCmd(fullImageName).exec();
        return imageResponse.getId();
    }

    /**
     * 给镜像打tag
     *
     * @param oldImageName  带tag
     * @param newImageName  不带tag
     * @param tag new镜像
     * @return
     */
    public void tagImage(String oldImageName, String newImageName, String tag) {
        this.dockerClient.tagImageCmd(oldImageName, newImageName, tag).exec();
        log.info("tag Docker image '{}' success", newImageName+":"+tag);
    }

	/**
	* push镜像到远端的私有huber仓库
	* name 镜像名
	* tag 
	**/
    public void pushImage(String name,String tagRes){
        PushImageCmd pushImageCmd = dockerClient.pushImageCmd(name).withTag(tagRes);
        PushImageResultCallback callback = new PushImageResultCallback() {
            @Override
            public void onNext(PushResponseItem item) {
                log.info(item.toString());
                super.onNext(item);
            }

            @Override
            public void onError(Throwable throwable) {
                log.error("Failed to exec start:" + throwable.getMessage());
                super.onError(throwable);
            }
        };
        pushImageCmd.exec(callback).awaitSuccess();
        log.info("push Docker image '{}' success", name+":"+tagRes);
    }

    /**
     * 获取远端仓库的所有镜像
     *
     * @return
     */
    public List<Image> listImages() {
        List<Image> images = this.dockerClient.listImagesCmd().exec();
        return images;
    }

    /**
     * 得到容器配置的标签
     *
     * @param containerId
     * @return
     */
    public Map<String, String> getLabels(String containerId) {
        InspectContainerResponse containerInfo = dockerClient.inspectContainerCmd(containerId).exec();
        return containerInfo.getConfig().getLabels();
    }



    /**
     * 得到docker的基本信息
     */
    public void getInfo() {
        Info info = dockerClient.infoCmd().exec();
        System.out.println("docker的环境信息如下：=================");
        System.out.println(info);
    }

}

/**
 * 操作docker的业务类
 */
@Service
@Slf4j
public class DockerService {

    @Autowired
    private LocalDockerManager dockerManager;

    @Value("${xxx.outer-registry}")
    private String outerRegistry;

    @Value("${xxx.registry-prefix}")
    private String registryPrefix;

    @Value("${xxx.gray-scale-version}")
    private String grayScaleVersion;

    @Value("${xxx.inner-registry}")
    private String innerRegistry;


    /**
     * 拉取docker镜像
     */
    public boolean pullImage(String groupName, String projectName, String originVersion) {
        String imagePath = outerRegistry + "/" + registryPrefix + "/" + groupName + "/" + projectName + ":" + originVersion;
        try {
            dockerManager.downloadDockerImage(imagePath, 90);
            return true;
        } catch (NotFoundException | InternalServerErrorException e) {
            if (dockerManager.dockerImageExistsLocally(imagePath)) {
                log.info("Docker image '{}' exists locally", imagePath);
                return true;
            } else {
                log.error("Error on Pulling '{}' image.{}", imagePath,e);
            }
        } catch (DockerClientException e) {
            log.error("Error on Pulling '{}' image. Probably because the user has stopped the execution {}", imagePath,e);
        } catch (InterruptedException e) {
            log.error("Error on Pulling '{}' image. Thread was interrupted: {}", imagePath, e);
        }
        return false;
    }

    /**
     * 镜像推送到远程仓库
     */
    public void pushImage(String groupName, String projectName) {
        String newImageName = outerRegistry + "/" + registryPrefix + "/" + groupName + "/" + projectName + "-" + grayScaleVersion;
        dockerManager.pushImage(newImageName, grayScaleVersion);
    }

    /**
     * 给镜像打标签
     * @param groupName
     * @param projectName
     * @param originVersion
     */
    public boolean tagImage(String groupName, String projectName, String originVersion) {
        String imagePath = outerRegistry + "/" + registryPrefix + "/" + groupName + "/" + projectName + ":" + originVersion;
        String newImageName = outerRegistry + "/" + registryPrefix + "/" + groupName + "/" + projectName + "-" + grayScaleVersion;
        dockerManager.tagImage(imagePath, newImageName, grayScaleVersion);
        return dockerManager.dockerImageExistsLocally(newImageName);
    }

参考：https://blog.csdn.net/u010245179/article/details/107067530

遇到这种push记得绕道，我记得是不好使（。。）

参考链接：
关于k8s的B2I容器化完整解决方案，使用docker-java将jar包构建镜像并推送至远程镜像仓库，并能在k8s中运行
docker-java Docker的java API（。。）
java操作docker示例（docker-java）
JavaAPI 对Docker的系列操作