java.lang.IllegalStateException: S3 파일 업로드 중 오류 발생
  ...
Caused by: software.amazon.awssdk.core.exception.SdkClientException:
  Unable to execute HTTP request: <bucket>.s3.<region>.amazonaws.com
Caused by: java.net.UnknownHostException: <bucket>.s3.<region>.amazonaws.com

{
  "topic": "reformatEnd",
  "eventTime": "2026-07-28T11:45:26.4250"
},
{
  "topic": "s3UploadStart",
  "eventTime": "2026-07-28T11:45:26.4250"
},
{
  "topic": "s3UploadEnd",
  "eventTime": "2026-07-28T11:45:31.4130"
},
{
  "topic": "s3UploadStart",
  "eventTime": "2026-07-28T11:45:31.4140"
},
{
  "topic": "s3UploadEnd",
  "eventTime": "2026-07-28T11:45:31.6260"
}

리포맷 종료   26.4250
업로드 시작   26.4250
업로드 종료   31.4130   →  4.988초    첫 시도 (jpg)
업로드 시작   31.4140
업로드 종료   31.6260   →  0.212초    원본 이미지 시도 (png)

25.861 ─────────────────────────→ 31.487
       26.425 ──────────────────→ 31.413
             26.617 ────────────→ 31.412
       └ 756ms 벌어져 시작            └ 75ms 안에 종료

25.861 ══════════════════▶ 31.487   A  ┐
26.425 ═════════════════▶ 31.413    B  ├ 첫 시도가 5초 (답을 기다렸다)
26.617 ════════════════▶ 31.412     C  ┘
                         │
                    31.4x 여기서 무슨 일이 있었다
                         │
                         31.660 ▶ 32.286     D  ┐
                             35.190 ▶ 35.904 E  ┴ 두 시도 다 0.5초 미만

첫 오류 시점이 보장된 로그 - 11:45:31.413
...
오류 발생 로그 - 11:45:34.117
...
오류 발생 로그 - 11:45:37.332
...
재성공 시점이 보장된 로그 - 11:45:41.402

t=0     업로드 시작, DNS 질의 전송
t≈5초   응답 없음 → resolver 타임아웃 → `UnknownHostException`
        이 실패가 기록되는 순간 JVM이 negative cache에 저장
t≈5~15초
        SDK 재시도는 실제 DNS 질의 없이 캐시된 실패를 읽고 즉시 종료
t≈15초  negative cache 만료 → 실제 DNS 질의 재개 → 성공

DefaultS3Client.putObject:11169
  └ RetryableStage.execute:56                                        ← 재시도 루프
      └ RetryableStage.executeRequest:93
          └ ApiCallAttemptMetricCollectionStage.execute:55
              └ TimeoutExceptionHandlingStage.execute:79
                  └ ApiCallAttemptTimeoutTrackingStage.execute:74
                      └ MakeHttpRequestStage.executeHttpRequest:79    ← 여기부터 HTTP
                          └ ApacheHttpClient.execute:254
                              └ InternalHttpClient.doExecute:185
                                  └ ProtocolExec.execute:186
                                      └ MainClientExec.execute:236
                                          └ MainClientExec.establishRoute:393   ← 커넥션 개설
                                              └ PoolingHttpClientConnectionManager.connect:376
                                                  └ DefaultHttpClientConnectionOperator.connect:112
                                                      └ SystemDefaultDnsResolver.resolve:45
                                                          └ InetAddress.getAllByName:1688

while (true) {
    try {
        retryableStageHelper.startingAttempt();
        // 아래 전부를 다시 탄다
        Response<OutputT> response = executeRequest(retryableStageHelper, context);   
        retryableStageHelper.recordAttemptSucceeded();
        return response;
    } catch (SdkExceptionWithRetryAfterHint | SdkException | IOException e) {
        ...
        Optional<Duration> backoffDelay = retryableStageHelper.tryRefreshToken(suggestedDelay);
        if (backoffDelay.isPresent()) {
           // 호출 스레드를 직접 재운다
            TimeUnit.MILLISECONDS.sleep(delay.toMillis());
        } else {
            throw retryableStageHelper.retryPolicyDisallowedRetryException();
        }
    }
}

// 커넥션이 닫혀 있을 때만 개설한다.
// 풀에서 꺼낸 소켓이 살아 있으면 조건이 false 라서 블록 전체를 건너뛴다.
if (!managedConn.isOpen()) {
    this.log.debug("Opening connection " + route);
    try {
        establishRoute(proxyAuthState, managedConn, route, request, context);   
    } catch (final TunnelRefusedException ex) {
	    ...
    }
}

// 여기서 DNS
final InetAddress[] addresses = host.getAddress() != null
        ? new InetAddress[] { host.getAddress() }
        : this.dnsResolver.resolve(host.getHostName());
final int port = this.schemePortResolver.resolve(host);
 
// 받은 주소를 순회한다.
// 이 환경에서는 S3 호스트명이 여러 주소로 해석될 수 있다.
for (int i = 0; i < addresses.length; i++) {              
    final InetAddress address = addresses[i];
    final boolean last = i == addresses.length - 1;
 
    Socket sock = sf.createSocket(context);
 
    final InetSocketAddress remoteAddress = new InetSocketAddress(address, port);
    try {
	    // 하나라도 붙으면 성공
        sock = sf.connectSocket(connectTimeout, sock, host, remoteAddress, localAddress, context);
        conn.bind(sock);
        return;                                           
    } catch (final SocketTimeoutException ex) {
        if (last) { throw new ConnectTimeoutException(ex, host, addresses); }
    } catch (final ConnectException ex) {
        if (last) { throw new HttpHostConnectException(ex, host, addresses); }
    } catch (final NoRouteToHostException ex) {
        if (last) { throw ex; }
    }
    // 세 예외 모두 마지막이 아니면 던지지 않고 다음 주소로 넘어간다
}

public class SystemDefaultDnsResolver implements DnsResolver {
 
    public static final SystemDefaultDnsResolver INSTANCE = new SystemDefaultDnsResolver();
 
    @Override
    public InetAddress[] resolve(final String host) throws UnknownHostException {
        return InetAddress.getAllByName(host);
    }
 
}

// look-up or remove from cache
Addresses addrs;
if (useCache) {
	// 있으면 CachedLookup 이 들어온다
    addrs = cache.get(host);          
}
...
if (addrs == null) {
    // 없으면 실제 조회할 객체를 만들어 캐시에 꽂는다
    Addresses oldAddrs = cache.putIfAbsent(host, addrs = new NameServiceAddresses(host));
    // putIfAbsent 경쟁에서 진 경우(경쟁에서 이긴 요소를 사용)
    if (oldAddrs != null) {           
        addrs = oldAddrs;
    }
}
 
// 위에서 정해진 구현체가 실행된다
return addrs.get().clone();           

public InetAddress[] get() throws UnknownHostException {
    Addresses addresses;
    // only one thread is doing lookup to name service
    // for particular host at any time.
    lookupLock.lock();
    try {
        addresses = cache.putIfAbsent(host, this);
        if (addresses == null) { addresses = this; }
        if (addresses == this) {
            InetAddress[] inetAddresses;
            UnknownHostException ex;
            int cachePolicy;
            try {
                // 실제 질의, native code (여기서 5초)
                inetAddresses = getAddressesFromNameService(host);
                ex = null;
                // 성공 → positive TTL 가져온다.
                cachePolicy = InetAddressCachePolicy.get();
            } catch (UnknownHostException uhe) {
	            // 주소를 null 로 처리
                inetAddresses = null;                                     
                ex = uhe;
                // 실패 → negative TTL 가져온다.
                cachePolicy = InetAddressCachePolicy.getNegative();       
            }
            // 캐시 사용하지 않게 설정한 경우
            if (cachePolicy == InetAddressCachePolicy.NEVER) {
                cache.remove(host, this);
            } else {
	            // 만료 시각 계산
                long now = System.nanoTime();
                long expiryTime = now + 1000_000_000L * cachePolicy;      
                CachedLookup cachedLookup = new CachedLookup(host, inetAddresses, expiryTime);
                // 실패도 캐시에 들어간다 !!
                cache.replace(host, this, cachedLookup);                  
            }
            if (inetAddresses == null || inetAddresses.length == 0) {
                throw ex == null ? new UnknownHostException(host) : ex;
            }
            return inetAddresses;
        }
    } finally {
        lookupLock.unlock();
    }
    return addresses.get();
}

/**
 * A cached result of a name service lookup. The result can be either valid
 * addresses or invalid (ie a failed lookup) containing no addresses.
 */
private static class CachedLookup implements Addresses, Comparable<CachedLookup> {
    final String host;
    volatile InetAddress[] inetAddresses;
    volatile long expiryTime;
 
    @Override
    public InetAddress[] get() throws UnknownHostException {
        if (inetAddresses == null) {
            throw new UnknownHostException(host);   // 988
        }
        return inetAddresses;
    }
}

NameServiceAddresses.get:1143   inetAddresses = null   → 캐시에 저장
                                        ↓
CachedLookup.get:988            if (inetAddresses == null) throw   → 즉시 실패

InetAddress.getAllByName()
  → JVM 프로세스 내 캐시 확인          ← 위에서 본 부분
    → (미스) PlatformResolver → 네이티브 lookupAllHostAddr
      → getaddrinfo
        → /etc/resolv.conf 의 nameserver
          → UDP:53 → 리졸버

public Stream<InetAddress> lookupByName(String host, LookupPolicy policy)
        throws UnknownHostException {
    validate(host);
    InetAddress[] addrs;
    // 이 호출은 블로킹이라고 JVM 에 알린다
    long comp = Blocker.begin();                        
    try {
	    // 네이티브 — 자바의 끝
        addrs = impl.lookupAllHostAddr(host, policy);    
    } finally {
        Blocker.end(comp);
    }
    return Arrays.stream(addrs);
}

docker exec <container-id> sh -c \
  'grep -n "networkaddress.cache" $JAVA_HOME/conf/security/java.security'

docker run --rm <image> sh -c \
  'grep -n "networkaddress.cache" $JAVA_HOME/conf/security/java.security'

#networkaddress.cache.ttl=-1
#networkaddress.cache.stale.ttl=0
networkaddress.cache.negative.ttl=10      ← 10초로 활성

t=0     업로드 시작, DNS 질의 전송
t≈5초   resolver 타임아웃 → `UnknownHostException`
        이 실패가 기록되는 순간 JVM이 negative cache에 저장
t≈5~15초
        SDK 재시도는 실제 DNS 질의 없이 캐시된 실패를 읽고 즉시 종료
t≈15초  negative cache 만료 → 실제 DNS 질의 재개 → 성공

// CachePolicy 에 설정된 값 사용
inetAddresses = getAddressesFromNameService(host);
cachePolicy = InetAddressCachePolicy.get();

public final class InetAddressCachePolicy {  
  
    // Controls the cache policy for successful lookups only  
    private static final String cachePolicyProp = "networkaddress.cache.ttl";  
    private static final String cachePolicyPropFallback =  
        "sun.net.inetaddr.ttl";  
  
    // Controls the cache stale policy for successful lookups only  
    private static final String cacheStalePolicyProp =  
        "networkaddress.cache.stale.ttl";  
    private static final String cacheStalePolicyPropFallback =  
        "sun.net.inetaddr.stale.ttl";  
  
    // Controls the cache policy for negative lookups only  
    private static final String negativeCachePolicyProp =  
        "networkaddress.cache.negative.ttl";
    ...
}

-Dnetworkaddress.cache.negative.ttl=0     ← 조용히 무효

System.getProperty()   = 0      ← 시스템 프로퍼티에는 저장됨
Security.getProperty() = null   ← 보안 프로퍼티는 비어있음
effective negative     = 10     ← 아무 일도 일어나지 않았다

Many users are setting networkaddress.cache.ttl as a system property [1].
This has no effect - this is a security property, and is only read from java.security file.

1. DNS 응답 한 번을 놓쳤다.
2. JVM 이 실패를 negative cache에 10초 캐싱한다.
3. S3 업로드 재시도는 10초 안에 끝나, 같은 캐시만 다시 읽고 처리했다.