百度360必应搜狗淘宝本站头条
mqtt服务器xftp6mybatiscollectionkeyerrorc#var
当前位置：网站首页 > 热门文章 > 正文

Spring Cloud Feign OkHttp Hystrix 常见问题&深入源码分析

bigegpt 2024-08-26 11:07 2 浏览


1、Spring Cloud Feign 最佳实践

在项目中，调用服务接口我们推荐使用feign并开启hystix熔断。

由于我们未采取Springcloud微服务的方案，所以就必须要在 @FeignClient 填写 url 这个参数指定地址。

微服务的情况下，需要注意配置ribbon，本文章忽略之

1.1、推荐配置

开启 hystix熔断，关闭feign的重试机制，使用okhttp并关闭okhttp的重试机制，feign的回退方式使用工厂模式。

1) maven

<dependency>
          <groupId>org.springframework.cloud</groupId>
          <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2) FeignOkHttpConfig

@Configuration
@ConditionalOnClass({Feign.class})
@AutoConfigureBefore(FeignAutoConfiguration.class)
public class FeignOkHttpConfig {
 
    @Value("${feign.okhttp3.connect-timeout.milliseconds:500}")
    private Long connectTimeout;
    @Value("${feign.okhttp3.read-timeout.milliseconds:1000}")
    private Long readTimeout;
    @Value("${feign.okhttp3.write-timeout.milliseconds:60000}")
    private Long writeTimeout;
 
    @Bean
    public okhttp3.OkHttpClient okHttpClient() {
        return new okhttp3.OkHttpClient.Builder()
                .connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
                .readTimeout(readTimeout, TimeUnit.MILLISECONDS)
                .writeTimeout(writeTimeout, TimeUnit.MILLISECONDS)
                .retryOnConnectionFailure(false)  // 关闭重试机制
                .connectionPool(new okhttp3.ConnectionPool())
                .build();
    }
 
    // 关闭重试
    @Bean
    Retryer feignRetry() {
        return Retryer.NEVER_RETRY;
    }
}

3) 配置文件

#feign
feign:
  httpclient:
    enabled: false
  hystrix:
    enabled: true  # hystrix 启用
  okhttp:
    enabled: true
  okhttp3:
    connect-timeout:
      milliseconds: 3000
    read-timeout:
      milliseconds: 3000
    write-timeout:
      milliseconds: 60000
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000
    bokeccLive: #cc云直播的熔断超时时间为1s
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1000
    study: #ep-study的熔断超时时间为1s
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1000
    resource: #资源中心的熔断超时时间为3s
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000
    sso: #资源中心的熔断超时时间为3s
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000
  threadpool:
    default:
      coreSize: 10
      maxQueueSize: 100
    bokeccLive: # cc云直播熔断线程池配置，QPS为50
      coreSize: 50
      maxQueueSize: 100
    study:  #ep-study熔断线程池配置，QPS为10
      coreSize: 10
      maxQueueSize: 100
    resource:  #资源中心熔断线程池配置，QPS为10
      coreSize: 30
      maxQueueSize: 100
    sso:  #公共服务熔断线程池配置，QPS为10
      coreSize: 50
      maxQueueSize: 100

下面就是我们线上大量系统优化后的生产经验总结：

假设你的服务A，每秒钟会接收30个请求，同时会向服务B发起30个请求，然后每个请求的响应时长经验值大概在200ms，那么你的hystrix线程池需要多少个线程呢？

计算公式是：30（每秒请求数量） * 0.2（每个请求的处理秒数） + 4（给点缓冲buffer） = 10（线程数量）

必须设置合理的参数，避免高峰期，频繁的hystrix线程卡死

如果hystix超时时间设置为500ms，那么1s中可以处理2个线程，所以如果需要让一个服务器达到100的并发，那么核心线程数需要配置到50才能达到处理每秒100的请求；

1.2、推荐实现

feign 的请求使用SpringMvc的注解，并且要求必须有回退且使用工厂模式

1) FeignClient

@FeignClient(name = "sso", url = "${services.ssoService.url}", fallbackFactory = SsoFeignClientFallbackFactory.class)
public interface SsoFeignClient {
 
    /**
     * 学生 ID 获取用户信息
     *
     * @param userId 学生 ID
     * @return 用户信息
     */
    @GetMapping(value = "/getbaseuserinfo/{userid}", headers = {"origin=gaodun.com"})
    BaseUserInfoResponse getBaseUserInfo(@PathVariable("userid") String userId);
}

2) FallbackFactory

@Slf4j
@Component
public class SsoFeignClientFallbackFactory implements FallbackFactory<SsoFeignClient> {
    @Override
    public SsoFeignClient create(Throwable throwable) {
        return userId -> {
            log.error("getBaseUserInfo,fallback;reason was:{}", throwable.getMessage(), throwable);
            return BaseUserInfoResponse.fallbackResult();
        };
    }
}

2、Spring Cloud Feign 性能优化

2.1 测试代码

feign&接口:

@FeignClient(name = "live", url = "http://127.0.0.1:8080/", fallbackFactory = LiveFeignClientFallbackFactory.class)
public interface LiveFeignClient {
    @GetMapping("/live/okhttp")
    BusinessResponse<Void> okhttp();
}

@GetMapping("/okhttp")
public BusinessResponse<Void> okhttp() {
    return BusinessResponse.ok();
}

代码的运行结果：

13:50:59.620 [http-nio-8080-exec-175] INFO  [] com.gaodun.storm.vod.aspect.ControllerLogAspect - LiveController.okhttp请求结束，耗时：0ms
13:50:59.619 [http-nio-8080-exec-138] INFO  [] com.gaodun.storm.vod.aspect.ControllerLogAspect - LiveController.feignOkhttp请求结束，耗时：215ms

以上的代码目的是检验feign的各项配置，由于接口的响应时间几乎忽略不计，那么请求接口的响应时长的表现，就是feign在调用第三方接口时，根据并发的情况和配置情况所需要的自身处理的时长

2.2 结果对比

jmeter 压测

1）默认项目配置测试结果

#使用okhttp,开启熔断
feign:
  httpclient:
    enabled: false
  hystrix:
    enabled: true 
  okhttp:
    enabled: true
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 300000
      circuitBreaker:
        requestVolumeThreshold: 10000
    live:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 300000
      circuitBreaker:
        requestVolumeThreshold: 10000
  threadpool:
    default:
      coreSize: 100
      maxQueueSize: 10000
      queueSizeRejectionThreshold: 8000
    live:
      coreSize: 100
      maxQueueSize: 10000
      queueSizeRejectionThreshold: 8000

默认压测结果截图：

2）根据经验配置优化以后的结果

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 300000
      circuitBreaker:
        requestVolumeThreshold: 10000
    live:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 1000
  threadpool:
    default:
      coreSize: 100
      maxQueueSize: 10000
      queueSizeRejectionThreshold: 8000
    live:
      coreSize: 10
      maxQueueSize: 100

优化后的压测结果：

2.3 总结

合理的设置核心线程池的大小，参考推荐配置；（Thread Pools 的 Active 设置的越大，当并发没有那么高的情况下，处理线程的耗时越长）

3、Spring Cloud Feign 实现原理

在微服务中，会使用到负载均衡，Feign集成了ribbon来实现，那么实际上处理 HTTP URL 请求的是 feignClient(…) 方法中的 feign.okhttp.LoadBalancerFeignClient.execute(…) 方法

其中okhttp的版本为 3.8.1，feign集成okhttp的版本如下：

<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-okhttp</artifactId>
    <version>10.1.0</version>
</dependency>

3.1 Feign 执行流程，源码解析（非微服务的情况下）

SynchronousMethodHandler 这里使用默认的， 如果是在微服务的情况下使用feign，那么需要分析的是：FeignLoadBalancer，也就是要理解Ribbon

1）SynchronousMethodHandler 同步方法处理器

请看在源码上的注释

final class SynchronousMethodHandler implements MethodHandler {
 
  private static final long MAX_RESPONSE_BUFFER_SIZE = 8192L;
 
  private final MethodMetadata metadata;
  private final Target<?> target;
  private final Client client;
  private final Retryer retryer;
  private final List<RequestInterceptor> requestInterceptors;
  private final Logger logger;
  private final Logger.Level logLevel;
  private final RequestTemplate.Factory buildTemplateFromArgs;
  private final Options options;
  private final Decoder decoder;
  private final ErrorDecoder errorDecoder;
  private final boolean decode404;
  private final boolean closeAfterDecode;
  private final ExceptionPropagationPolicy propagationPolicy;
 
  private SynchronousMethodHandler(Target<?> target, Client client, Retryer retryer,
      List<RequestInterceptor> requestInterceptors, Logger logger,
      Logger.Level logLevel, MethodMetadata metadata,
      RequestTemplate.Factory buildTemplateFromArgs, Options options,
      Decoder decoder, ErrorDecoder errorDecoder, boolean decode404,
      boolean closeAfterDecode, ExceptionPropagationPolicy propagationPolicy) {
    this.target = checkNotNull(target, "target");
    this.client = checkNotNull(client, "client for %s", target);
    this.retryer = checkNotNull(retryer, "retryer for %s", target);
    this.requestInterceptors =
        checkNotNull(requestInterceptors, "requestInterceptors for %s", target);
    this.logger = checkNotNull(logger, "logger for %s", target);
    this.logLevel = checkNotNull(logLevel, "logLevel for %s", target);
    this.metadata = checkNotNull(metadata, "metadata for %s", target);
    this.buildTemplateFromArgs = checkNotNull(buildTemplateFromArgs, "metadata for %s", target);
    this.options = checkNotNull(options, "options for %s", target);
    this.errorDecoder = checkNotNull(errorDecoder, "errorDecoder for %s", target);
    this.decoder = checkNotNull(decoder, "decoder for %s", target);
    this.decode404 = decode404;
    this.closeAfterDecode = closeAfterDecode;
    this.propagationPolicy = propagationPolicy;
  }
 
  @Override
  public Object invoke(Object[] argv) throws Throwable {
     
    RequestTemplate template = buildTemplateFromArgs.create(argv);
 
    Retryer retryer = this.retryer.clone();
    while (true) {
      try {
        return executeAndDecode(template);
      } catch (RetryableException e) {
        try {
          retryer.continueOrPropagate(e);
        } catch (RetryableException th) {
          Throwable cause = th.getCause();
          if (propagationPolicy == UNWRAP && cause != null) {
            throw cause;
          } else {
            throw th;
          }
        }
        if (logLevel != Logger.Level.NONE) {
          logger.logRetry(metadata.configKey(), logLevel);
        }
        continue;
      }
    }
  }
 
  Object executeAndDecode(RequestTemplate template) throws Throwable {
    Request request = targetRequest(template);
 
    if (logLevel != Logger.Level.NONE) {
      logger.logRequest(metadata.configKey(), logLevel, request);
    }
 
    Response response;
    long start = System.nanoTime();
    try {
      // 使用 OkHttpClient 获取结果
      response = client.execute(request, options);
 
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
      }
      throw errorExecuting(request, e);
    }
    long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
 
   // 解析此Response对象，解析后return（返回Object：可能是Response实例，也可能是decode解码后的任意类型）。
    boolean shouldClose = true;
    try {
      if (logLevel != Logger.Level.NONE) {
        response =
            logger.logAndRebufferResponse(metadata.configKey(), logLevel, response, elapsedTime);
      }
      if (Response.class == metadata.returnType()) {
        if (response.body() == null) {
          return response;
        }
        if (response.body().length() == null ||
            response.body().length() > MAX_RESPONSE_BUFFER_SIZE) {
          shouldClose = false;
          return response;
        }
        // Ensure the response body is disconnected
        byte[] bodyData = Util.toByteArray(response.body().asInputStream());
        return response.toBuilder().body(bodyData).build();
      }
      if (response.status() >= 200 && response.status() < 300) {
        if (void.class == metadata.returnType()) {
          return null;
        } else {
          Object result = decode(response);
          shouldClose = closeAfterDecode;
          return result;
        }
      } else if (decode404 && response.status() == 404 && void.class != metadata.returnType()) {
        Object result = decode(response);
        shouldClose = closeAfterDecode;
        return result;
      } else {
        throw errorDecoder.decode(metadata.configKey(), response);
      }
    } catch (IOException e) {
      if (logLevel != Logger.Level.NONE) {
        logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime);
      }
      throw errorReading(request, response, e);
    } finally {
      if (shouldClose) {
        ensureClosed(response.body());
      }
    }
  }
 
  long elapsedTime(long start) {
    return TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);
  }
 
  Request targetRequest(RequestTemplate template) {
    for (RequestInterceptor interceptor : requestInterceptors) {
      interceptor.apply(template);
    }
    return target.apply(template);
  }
 
  Object decode(Response response) throws Throwable {
    try {
      return decoder.decode(response, metadata.returnType());
    } catch (FeignException e) {
      throw e;
    } catch (RuntimeException e) {
      throw new DecodeException(e.getMessage(), e);
    }
  }
 
  static class Factory {
 
    private final Client client;
    private final Retryer retryer;
    private final List<RequestInterceptor> requestInterceptors;
    private final Logger logger;
    private final Logger.Level logLevel;
    private final boolean decode404;
    private final boolean closeAfterDecode;
    private final ExceptionPropagationPolicy propagationPolicy;
 
    Factory(Client client, Retryer retryer, List<RequestInterceptor> requestInterceptors,
        Logger logger, Logger.Level logLevel, boolean decode404, boolean closeAfterDecode,
        ExceptionPropagationPolicy propagationPolicy) {
      this.client = checkNotNull(client, "client");
      this.retryer = checkNotNull(retryer, "retryer");
      this.requestInterceptors = checkNotNull(requestInterceptors, "requestInterceptors");
      this.logger = checkNotNull(logger, "logger");
      this.logLevel = checkNotNull(logLevel, "logLevel");
      this.decode404 = decode404;
      this.closeAfterDecode = closeAfterDecode;
      this.propagationPolicy = propagationPolicy;
    }
 
    public MethodHandler create(Target<?> target,
                                MethodMetadata md,
                                RequestTemplate.Factory buildTemplateFromArgs,
                                Options options,
                                Decoder decoder,
                                ErrorDecoder errorDecoder) {
      return new SynchronousMethodHandler(target, client, retryer, requestInterceptors, logger,
          logLevel, md, buildTemplateFromArgs, options, decoder,
          errorDecoder, decode404, closeAfterDecode, propagationPolicy);
    }
  }
}

2）重试机制

默认的重试机制：

默认的请求次数为5次，如下：
参数一：为下次发起重试请求 生成间隔时间算法的参数（时间单位：毫秒）
参数二：距下次发起重试请求最大的间隔时间（时间单位：毫秒）
public Default() {
  this(100, SECONDS.toMillis(1), 5);
}

获取下一次重试间隔时间

/**
 * Calculates the time interval to a retry attempt. <br>
 * The interval increases exponentially with each attempt, at a rate of nextInterval *= 1.5
 * (where 1.5 is the backoff factor), to the maximum interval.
 *
 * @return time in nanoseconds from now until the next attempt.
 */
long nextMaxInterval() {
  long interval = (long) (period * Math.pow(1.5, attempt - 1));
  return interval > maxPeriod ? maxPeriod : interval;
}

取消feign重试

//取消重试
 @Bean
 Retryer feignRetry() {
     return Retryer.NEVER_RETRY;
 }

3.2、 Feign 使用OkHttp，Okhttp的实现原理

1）feign client 通过 OkHttpClient 完成request 到 Response的一次请求

使用 feign.okhttp.OkHttpClient (注意和okhttp3.OkHttpClient是不一样的),

实际上处理 HTTP URL 请求的是 feignClient(…) 方法中的 feign.okhttp.OkHttpClient.execute(…) 方法，源码如下：

@Override
public feign.Response execute(feign.Request input, feign.Request.Options options)
    throws IOException {
  okhttp3.OkHttpClient requestScoped;
  if (delegate.connectTimeoutMillis() != options.connectTimeoutMillis()
      || delegate.readTimeoutMillis() != options.readTimeoutMillis()) {
    requestScoped = delegate.newBuilder()
        .connectTimeout(options.connectTimeoutMillis(), TimeUnit.MILLISECONDS)
        .readTimeout(options.readTimeoutMillis(), TimeUnit.MILLISECONDS)
        .followRedirects(options.isFollowRedirects())
        .build();
  } else {
    requestScoped = delegate;
  }
  Request request = toOkHttpRequest(input);
  Response response = requestScoped.newCall(request).execute();
  return toFeignResponse(response, input).toBuilder().request(input).build();
}

在默认没有配置的情况下，Options的初始化参数如下：

public Options() {
  this(10 * 1000, 60 * 1000);
}
 
 
// connectTimeoutMillis = 10_000
// readTimeoutMillis = 60_000

也可以通过配置文件来修改默认配置，配置如下：

// default 为默认的，也可以根据feign的value值，单独配置
feign.client.config.default.connectTimeout=1000
feign.client.config.default.readTimeout=10000

从源码可以看到，feign使用okhttp时，超时时间优先根据client的时间来设置

2）okhttp 执行层

// 其中requestScoped 是 okhttp3.OkHttpClient 的实例
Response response = requestScoped.newCall(request).execute();

这是应用程序中发起网络请求最顶端的调用，newCall(request) 方法返回 RealCall 对象。

RealCall 封装了一个 request 代表一个请求调用任务，RealCall 有两个重要的方法 execute() 和 enqueue(Callback responseCallback)。

execute() 是直接在当前线程执行请求，enqueue(Callback responseCallback) 是将当前任务加到任务队列中，执行异步请求。(异步请求的执行流程会在后续讲解)

3) 同步请求

@Override public Response execute() throws IOException {
  synchronized (this) {
    if (executed) throw new IllegalStateException("Already Executed");
    executed = true;
  }
  captureCallStackTrace();
  try {
    client.dispatcher().executed(this);
    Response result = getResponseWithInterceptorChain();
    if (result == null) throw new IOException("Canceled");
    return result;
  } finally {
    client.dispatcher().finished(this);
  }
}

从执行层说到连接层，涉及到 getResponseWithInterceptorChain 方法中组织的各个拦截器的执行过程，其中 getResponseWithInterceptorChain 是关键，它使用了 责任链设计模式

4) 连接器执行过程(关键)

Response getResponseWithInterceptorChain() throws IOException {
  // Build a full stack of interceptors.
  List<Interceptor> interceptors = new ArrayList<>();
  interceptors.addAll(client.interceptors());
  interceptors.add(retryAndFollowUpInterceptor);
  interceptors.add(new BridgeInterceptor(client.cookieJar()));
  interceptors.add(new CacheInterceptor(client.internalCache()));
  interceptors.add(new ConnectInterceptor(client));
  if (!forWebSocket) {
    interceptors.addAll(client.networkInterceptors());
  }
  interceptors.add(new CallServerInterceptor(forWebSocket));
 
  Interceptor.Chain chain = new RealInterceptorChain(
      interceptors, null, null, null, 0, originalRequest);
  return chain.proceed(originalRequest);
}

5) Okhttp3 拦截器 RetryAndFollowUpInterceptor 重试机制

此拦截器将从故障中恢复，并根据需要执行重定向。如果调用被取消，它会抛出 *{@link IOException}

关于重定向次数：

/**
 * How many redirects and auth challenges should we attempt? Chrome follows 21 redirects; Firefox,
 * curl, and wget follow 20; Safari follows 16; and HTTP/1.0 recommends 5.
 */
private static final int MAX_FOLLOW_UPS = 20;

6) Okhttp3 拦截器 BridgeInterceptor 桥梁

一个实现应用层和网络层直接的数据格式编码的桥。

第一： 把应用层客户端传过来的请求对象转换为 Http 网络协议所需字段的请求对象。第二: 把下游网络请求结果转换为应用层客户所需要的响应对象

默认设置HTTP长连接（开启Keep-Alive功能可使客户端到服务器端的连接持续有效,当出现对服务器的后继请求时,Keep-Alive功能避免了建立或者重新建立连接。）

if (userRequest.header("Connection") == null) {
  requestBuilder.header("Connection", "Keep-Alive");
}

7) Okhttp3 拦截器 CacheInterceptor 缓存

为来自缓存的请求提供服务，并将响应写入缓存

8) Okhttp3 拦截器 ConnectInterceptor 连接

打开到目标服务器的连接并继续到下一个拦截器。

9) Okhttp3 拦截器 CallServerInterceptor 网络调用

这是链中的最后一个拦截器。它对服务器进行网络调用。

10) ConnectionPool 实现

管理HTTP和HTTP/2连接的重用以减少网络延迟

HTTP请求共享同一{@link Address} ，共享同一{@link Connection}

实现策略为将来使用而保持开放的连接。

默认实现中，使用一个双向队列来缓存所有连接， 这些连接中最多只能存在 5 个空闲连接，空闲连接最多只能存活 5 分钟。


/**
 * Create a new connection pool with tuning parameters appropriate for a single-user application.
 * The tuning parameters in this pool are subject to change in future OkHttp releases. Currently
 * this pool holds up to 5 idle connections which will be evicted after 5 minutes of inactivity.
 */
public ConnectionPool() {
  this(5, 5, TimeUnit.MINUTES);
}

如何复用Connection：遍历了所有的连接，然后判断某个连接是否可以复用；http1.x协议下当前socket没有其他流正在读写时可以复用，否则不行，http2.0对流数量没有限制。

如何清理连接池：每次put一个新连接的时候都会判断是否需要清理。遍历当前所有连接，跳过正在使用的连接，其他没有用的连接，如果哪个连接超过了规定的时间，就关掉这个socket。如果都没有超过规定时间的，就返回离规定时间最近的那个差值。拿到那个时间值后，我们再回到上面那个cleanupRunnable中，在那里会wait线程，然后醒来继续清理

以上论述，仅代表个人观点，作者水平有限，如有错误，欢迎批评指正。

相关推荐

Docker篇(二):Docker实战，命令解析

大家好，我是杰哥上周我们通过几个问题，让大家对于Docker有了一个全局的认识。然而，说跟练往往是两个概念。从学习的角度来说，理论知识的学习，往往只是第一步，只有经过实战，才能真正掌握一门技术所以，本...

docker学习笔记——安装和基本操作

今天学习了docker的基本知识,记录一下docker的安装步骤和基本命令(以CentOS7.x为例)一、安装docker的步骤：1.yuminstall-yyum-utils2.yum-con...

不可错过的Docker完整笔记（dockerhib）

简介一、Docker简介Docker是一个开源的应用容器引擎，基于Go语言并遵从Apache2.0协议开源。Docker可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中，...

扔掉运营商的 IPTV 机顶盒，全屋全设备畅看 IPTV!

其实现在看电视节目的需求确实大大降低了，折腾也只是为了单纯的让它实现，享受这个过程带来的快乐而已，哈哈！预期构想家里所有设备直接接入网络随时接收并播放IPTV直播（电信点播的节目不是太多，但好在非常稳...

第五节 Docker 入门实践:从 Hello World 到容器操作

一、Docker容器基础运行（一）单次命令执行通过dockerrun命令可以直接在容器中执行指定命令，这是体验Docker最快捷的方式：#在ubuntu:15.10容器中执行ech...

替代Docker build的Buildah简单介绍

Buildah是用于通过较低级别的coreutils接口构建OCI兼容镜像的工具。与Podman相似，Buildah不依赖于Docker或CRI-O之类的守护程序，并且不需要root特权。Builda...

Docker 命令大全（docker命令大全记录表）

容器生命周期管理run-创建并启动一个新的容器。start/stop/restart-这些命令主要用于启动、停止和重启容器。kill-立即终止一个或多个正在运行的容器rm-于删除一个或...

docker常用指令及安装rabbitMQ（docker安装rabbitmq配置环境）

一、docker常用指令启动docker：systemctlstartdocker停止docker：systemctlstopdocker重启docker：systemctlrestart...

使用Docker快速部署Storm环境（docker部署confluence）

Storm的部署虽然不是特别麻烦，但是在生产环境中，为了提高部署效率，方便管理维护，使用Docker来统一管理部署是一个不错的选择。下面是我开源的一个新的项目，一个配置好了storm与mono环境的D...

Docker Desktop安装使用指南:零基础教程

在之前的文章中，我多次提到使用Docker来安装各类软件，尤其是开源软件应用。鉴于不少读者对此有需求，我决定专门制作一期关于Docker安装与使用的详细教程。我主要以Macbook（Mac平台）为例进...

Linux如何成功地离线安装docker（linux离线安装httpd）

系统环境：Redhat7.2和Centos7.4实测成功近期因项目需要用docker，所以记录一些相关知识，由于生产环境是不能直接连接互联网，尝试在linux中离线安装docker。步骤1.下载...

Docker 类面试题(常见问题)（docker面试题目）

Docker常见问题汇总镜像相关1、如何批量清理临时镜像文件？可以使用sudodockerrmi$(sudodockerimages-q-fdanging=true)命令2、如何查看...

面试官:你知道Dubbo怎么优雅上下线的吗?你:优雅上下线是啥?

最近无论是校招还是社招，都进行的如火如荼，我也承担了很多的面试工作，在一次面试过程中，和候选人聊了一些关于Dubbo的知识。Dubbo是一个比较著名的RPC框架，很多人对于他的一些网络通信、通信协议、...

【Docker 新手入门指南】第五章:Hello Word

适合人群：完全零基础新手|学习目标：30分钟掌握Docker核心操作一、准备工作：先确认是否安装成功打开终端（Windows用户用PowerShell或GitBash），输入：docker--...

松勤软件测试:详解Docker，如何用portainer管理Docker容器

镜像管理搜索镜像dockersearch镜像名称拉取镜像dockerpullname[:tag]列出镜像dockerimages删除镜像dockerrmiimage名称或id删除...

一周热门
最近发表
标签列表