}

func runDNSCache(ctx *cli.Context) {
	dnsTTL := ctx.Duration("dns-cache-ttl")
	// Check if we have configured a custom DNS cache TTL.
	if dnsTTL <= 0 {
		if orchestrated {
			dnsTTL = 30 * time.Second
		} else {
			dnsTTL = 10 * time.Minute
		}
	}

	// Call to refresh will refresh names in cache.
	go func() {
		// Baremetal setups set DNS refresh window up to dnsTTL duration.
		t := time.NewTicker(dnsTTL)

@Tag("Slowish")
class DnsOverHttpsTest {
  @RegisterExtension
  val platform = PlatformRule()

  @StartStop
  private val server = MockWebServer()

  private lateinit var dns: Dns
  private val cacheFs = FakeFileSystem()
  private val eventRecorder = EventRecorder()
  private val bootstrapClient =
    OkHttpClient
      .Builder()
      .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))

    var routeSelector = newRouteSelector(address)
    dns[PROXY_A_HOST] = dns.allocate(1)
    dns[PROXY_B_HOST] = dns.allocate(1)

    // Mark the ProxyA route as failed.
    val selection = routeSelector.next()
    dns.assertRequests(PROXY_A_HOST)
    val route = selection.next()
    assertRoute(route, address, proxyA, dns.lookup(PROXY_A_HOST, 0), PROXY_A_PORT)
    routeDatabase.failed(route)

    return copy(writeTimeoutMillis = checkDuration("writeTimeout", timeout.toLong(), unit))
  }

  override fun withDns(dns: Dns): Interceptor.Chain {
    check(exchange == null) { "dns can't be adjusted in a network interceptor" }

    return copy(dns = dns)
  }

  override fun withSocketFactory(socketFactory: SocketFactory): Interceptor.Chain {

  @BeforeEach
  fun setUp() {
    socketFactory = SpecificHostSocketFactory(InetSocketAddress(server1.hostName, server1.port))

    client =
      clientTestRule
        .newClientBuilder()
        .dns(dns)
        .socketFactory(socketFactory)
        .eventListenerFactory(clientTestRule.wrap(eventRecorder))
        .build()
  }

  @RepeatedTest(100)
  fun http2OneBadHostOneGoodNoRetryOnConnectionFailure() {

///

### DNS { #dns }

Теперь сфокусируемся на собственно частях, связанных с HTTPS.

Сначала браузер спросит у **DNS‑серверов**, какой **IP соответствует домену**, в нашем примере `someapp.example.com`.

DNS‑серверы ответят браузеру, какой **конкретный IP‑адрес** использовать. Это будет публичный IP‑адрес вашего сервера, который вы указали в настройках DNS.

        .addSubjectAlternativeName("differentdns.com")
        .build()
    serverIps = Dns.SYSTEM.lookup(server.hostName)
    dns[server.hostName] = serverIps
    dns["san.com"] = serverIps
    dns["nonsan.com"] = serverIps
    dns["www.wildcard.com"] = serverIps
    dns["differentdns.com"] = listOf()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()

    object DnsOverride : Override<Dns> {
      override fun Interceptor.Chain.value(): Dns = dns

      override fun Interceptor.Chain.withOverride(value: Dns): Interceptor.Chain = withDns(value)

      override fun OkHttpClient.Builder.withOverride(value: Dns): OkHttpClient.Builder = dns(value)

      override val nonDefaultValue: Dns = Dns { Dns.SYSTEM.lookup(it) }

	}
	if err == nil && dnsURL != "" {
		bootstrapTraceMsg("initialize remote bucket DNS store")
		globalDNSConfig, err = dns.NewOperatorDNS(dnsURL,
			dns.Authentication(dnsUser, dnsPass),
			dns.RootCAs(globalRootCAs))
		if err != nil {
			configLogIf(ctx, fmt.Errorf("Unable to initialize remote webhook DNS config %w", err))
		}
	}

///

### DNS { #dns }

Тепер зосередьмося на всіх власне частинах HTTPS.

Спочатку браузер звернеться до **DNS-серверів**, щоб дізнатися, яка **IP-адреса для домену**, у цьому випадку `someapp.example.com`.

Сервери DNS повідомлять браузеру використати конкретну **IP-адресу**. Це буде публічна IP-адреса, яку використовує ваш сервер і яку ви налаштували на серверах DNS.