GitHub 2026년 10월 가용성 보고서를 읽고
들어가며
11월 12일, GitHub에서 2026년 10월 가용성 보고서를 공개했다.
깃허브는 매달 서비스 운영 중 발생한 장애와 그 원인, 해결 과정, 재발을 막기 위해 무엇을 했는지 개선 사항을 공개하고 있다.
이번 보고서에서는 10월 한 달 동안 발생한 총 8건의 장애를 다루고 있었는데,
그 중 개인적으로 흥미로웠던 세 가지 사례를 다뤄보고자 한다.
- 잘못된 데이터베이스 라우팅 정보로 쓰기 작업이 중단된 건
- 캐시 서버 재연결 요청이 폭주하면서 네트워크가 포화된 건
- 데이터베이스 커넥션 풀이 고갈되면서 요청이 실패한 건
특히 재연결 폭주와 커넥션 풀 고갈은 백엔드 개발 중에도 충분히 마주할 수 있는 문제라고 생각이 들었기에,
이번 글에서는 위 세 가지 장애가 어떤 이유로 발생했는지 살펴보고, 깃허브는 이 문제를 어떻게 해결했는지 정리해보고자 한다.
1. 잘못된 데이터베이스 라우팅
1.1 장애 유형
10월 7일, GitHub에서는 두 차례에 걸쳐 데이터베이스 쓰기 작업이 실패하는 장애가 발생했다고 한다.
첫 번째 장애는 약 10분, 두 번째 장애는 약 9분간 지속되었다.
이 과정에서 Push, PR 및 Issue 수정, 로그인, API를 통한 변경 작업 등이 영향을 받았다.
반면 읽기 작업은 대부분 정상적으로 동작했다고 한다.
그렇다면 데이터베이스 전체가 중단된 건 아닌데, 왜 쓰기 작업만 실패했을까 ?
원인은 데이터베이스 자체가 아니라, 쓰기 요청을 전달하는 라우팅 정보에 있었다.
1.2 데이터베이스 라우팅
일반적인 데이터베이스 환경에서는 애플리케이션이 하나의 데이터베이스 서버에 연결해 읽기, 쓰기 작업을 수행할 수 있다.
하지만 서비스 규모가 커지면 하나의 데이터베이스 서버만으로는 모든 요청을 처리하기 어려워진다.
이때 Primary와 Replica를 이용해 읽기와 쓰기 작업을 분리하는 구조를 사용할 수 있다.
Application
|
DB Router
|
+--------+--------+
| |
Primary Replica
| |
INSERT SELECT
UPDATE
DELETE
일반적으로 Primary는 쓰기 작업을 처리하고, Replica는 읽기 작업을 분산하는 데 사용된다.
저번에 Redis에서 살펴봤던 Master/Replica 구조와 같은 개념이다.
MySQL이나 PostgreSQL에서는 주로 Primary/Replica 라는 용어를 사용한다.
물론 실제 구성은 서비스마다 다르며, 모든 읽기 요청이 반드시 Replica로 전달되는 것은 아니다.
여기서 중요한 것은 애플리케이션의 요청을 어떤 데이터베이스 서버로 전달할지 결정하는 라우팅 정보이다.
예를 들어 다음과 같은 설정이 있다고 가정해보자.
Primary -> DB-A
Replica -> DB-B
이후 장애 조치나 서버 교체로 Primary가 DB-C로 변경되었다면, 라우팅 정보도 변경되어야 한다.
Primary -> DB-C
Replica -> DB-B
그런데 라우팅 정보가 갱신되지 않아 여전히 DB-A를 가리키고 있다면 어떻게 될까 ?
애플리케이션은 정상적으로 요청을 보내지만, 실제 쓰기 작업은 실패한다.
1.3 장애 원인
GitHub는 정기 유지보수 과정에서 데이터베이스 라우팅을 관리하는 서버를 교체했다고 한다.
그런데 새롭게 투입된 서버에 이미 폐기된 데이터베이스 서버의 정보가 남아 있던 것이었다.
문제는 그 서버가 라우팅 관리 시스템의 리더로 선출되면서 발생했다.
리더가 된 서버는 자신이 보유한 폐기됐던 라우팅 정보를 게시했고,
그 결과 일부 쓰기 요청이 더이상 사용하지 않는 데이터베이스 서버로 전달되었다.
정리하자면 다음과 같다.
1. 데이터베이스 라우팅 관리 서버 교체
2. 새 서버에 오래된 DB 정보가 남아 있었음
3. 해당 서버가 리더로 선출됨
4. 오래된 라우팅 정보가 적용됨
5. 쓰기 요청이 폐기된 DB 서버로 전달됨
6. GitHub 쓰기 작업 실패
1.4 두 번 발생한 이유
첫 번째 장애 이후 GitHub는 정상적인 라우팅 정보가 다시 적용되도록 조치했다고 한다.
그리고 문제가 반복되지 않도록 자동 유지보수 작업을 일시 중단했다.
하지만 일부 자동화 작업이 중단 지시를 따르지 않았고, 문제가 있는 서버가 다시 리더로 선출되면서 동일한 장애가 다시 발생했다.
개인적으로 이 부분이 흥미롭게 느껴졌는데,
서비스를 안정적으로 운영하기 위해 도입한 자동화 시스템이 오히려 장애를 반복시키는 원인이 되었기 때문이다.
1.5 해결 방법
GitHub는 이번 장애 이후 다음과 같은 개선을 했다.
- 폐기된 데이터베이스 서버 정보가 남지 않도록 정리
- 라우팅 관리 서버를 추가하는 과정 검증 강화
- 잘못된 라우팅 정보가 실제 서비스에 적용되지 않도록 검증 강화
- 자동 유지보수 작업이 중단 지시를 확실히 따르도록 개선
이번 사례를 통해 알 수 있었던 것은 자동화된 복구 시스템이 존재한다고 해서 반드시 올바른 상태로 복구되는 것은 아니라는 점이다.
특히 분산 시스템에서는 리더 선출뿐만 아니라 설정의 유효성과 최신 상태를 검증하는 과정도 중요하다는 생각이 들었다.
2. 재연결 폭주
2.1 장애 유형
10월 19일, GitHub Actions와 관련된 내부 서비스에서 장애가 발생했다.
Actions 실행 로그와 상태를 저장하는 서비스가 특정 클라우드 리전의 캐시 서버 일부와 연결이 끊어진 것이다.
일반적으로 애플리케이션은 외부 서비스와의 연결이 끊어지면 재연결하려고 한다.
일시적인 네트워크 오류라면 재연결만으로 상태 회복이 가능하기 때문이다.
그런데 이번에는 재연결을 시도하는 과정에서 더 큰 문제가 발생했는데,
여러 애플리케이션 서버가 거의 동시에 캐시 서버에 재연결을 시도하면서, GitHub 데이터센터와 클라우드 리전 사이의 네트워크 구간이 포화 상태가 된 것이다.
결과적으로 GitHub Actions뿐 아니라 같은 네트워크를 사용하는 다른 서비스에도 영향을 미쳤다고 한다.
2.2 Retry Storm
일반적인 백엔드 애플리케이션에서는 외부 서비스 호출에 실패했을 때 재시도 로직을 적용할 수 있다.
단일 애플리케이션에서 소수의 재시도라면 큰 문제가 발생하지 않지만, 수백 대의 애플리케이션 서버가 동시에 재시도를 시도한다면 어떻게 될까 ?
예를 들어 애플리케이션 서버 100대가 각각 Redis 서버와 20개의 연결을 유지한다고 가정해보자.
모든 연결이 동시에 끊어지고 각 서버가 즉시 재연결을 시도한다면 최대 2,000개의 연결 요청이 짧은 시간에 집중된다.
문제는 서버가 과부하로 재연결 요청을 받아들이지 못하는 상황에서도 클라이언트가 계속해서 재시도할 수 있다는 점이다.
이처럼 실패한 요청을 복구하기 위한 재시도가 오히려 시스템에 더 큰 부하를 발생시키는 현상을 Retry Storm이라고 한다.
이번 장애에서는 재연결 요청이 공유 네트워크 구간에 집중되면서 문제가 발생했다.
2.3 해결 방법
가장 먼저 생각해 볼 수 있는 방법은 재시도 사이에 대기 시간을 두는 것이다.
연결에 실패한 경우 n초 후 다시 시도하는 식으로 ,,
하지만 모든 애플리케이션 서버가 동일한 시점에 실패하고, 동일한 간격으로 재시도한다면 여전히 문제가 발생한다.
따라서 단순히 일정 시간을 기다리는 것만으로는 충분하지 않은데,
이때 사용할 수 있는 방법이 바로 Exponential Backoff와 Jitter이다.
2.4 Exponential Backoff와 Jitter
Exponential Backoff는 재시도 횟수가 증가할수록 대기 시간을 점진적으로 늘리는 방식이다.
예를 들어 다음과 같이 재시도 요청을 보낼 수 있다.
재시도 1회 -> 1초 대기 후 재시도
재시도 2회 -> 2초 대기 후 재시도
재시도 3회 -> 4초 대기 후 재시도
재시도 4회 -> 8초 대기 후 재시도
재시도 5회 -> 16초 대기 후 재시도
...
이렇게 하면 장애가 지속되는 동안 클라이언트가 서버에 과도한 재시도 요청을 보내는 상황을 줄일 수 있다.
하지만 마찬가지로 여기에도 문제가 있는데,
모든 서버가 동일한 시점에 재시도를 시작한다면 대기 시간이 늘어나더라도 요청이 몰리는 시점은 여전히 동일하다는 것이다.
이를 완화하기 위해 사용하는 것이 Jitter이다.
Jitter는 재시도 대기 시간에 무작위성을 추가하는 방식이다.
예를 들어 재시도 대기 시간이 4초라면, 모든 서버가 정확히 4초를 기다리는 대신, 서로 다른 시간에 재시도하도록 만드는 것이다.
Jitter 적용 전
App A ---- 4초 ----> Retry
App B ---- 4초 ----> Retry
App C ---- 4초 ----> Retry
Jitter 적용 후
App A -- 2.3초 --> Retry
App B ---- 3.7초 ----> Retry
App C - 1.5초 -> Retry
이처럼 재시도 시점을 분산하면 여러 서버의 요청이 동시에 들어오는 경우를 방지할 수 있다.
물론 Backoff와 Jitter만으로 모든 문제를 해결할 수 있는 것은 아니다.
서버가 감당할 수 있도록 연결 생성 속도를 제한하거나, 일정 횟수 이상 실패한 경우 재시도를 막는 등의 정책도 함께 고려해볼 수 있다.
2.5 GitHub의 해결방법
GitHub는 문제가 발생한 캐시 서버로 향하는 트래픽을 단계적으로 우회시켰다고 한다.
이후 네트워크 사용량이 정상화되자, GitHub Actions의 처리 한도를 높여 밀려 있던 작업을 처리했다.
재발 방지를 위해서 캐시 서버에 새 연결을 생성하는 속도를 제한하고, 비정상적인 연결 증가를 감지할 수 있도록 모니터링을 개선했다.
3. 커넥션 풀 고갈
3.1 장애 유형
10월 30일, GitHub에서는 데이터베이스 커넥션 풀이 고갈되면서 약 9분 동안 장애가 발생했다.
장애가 가장 심각했던 시점에는 PR Merge 요청의 약 43%, 전체 API 요청의 약 3.5%가 실패했다고 한다.
데이터베이스에 연결할 수 있는 커넥션이 모두 사용 중이어서 새로운 요청이 커넥션을 확보하지 못한 것이다.
3.2 Connection Pool 이란
애플리케이션이 데이터베이스에 접근하려면 데이터베이스와 연결되어야 한다. (당연하다)
그런데 요청이 발생할 때마다 새로운 연결을 생성하고 작업이 끝나면 연결을 종료하는 방식은 비효율적이다.
연결을 생성하고 인증하는 과정에서도 비용이 발생하기 때문이다.
이를 개선하기 위해 미리 일정 수의 커넥션을 생성하고 재사용하는 방식을 사용하는데, 이것이 Connection Pool이다.
Spring Boot에서는 일반적으로 HikariCP를 사용한다.
예를 들어 커넥션 풀 크기가 3이고, 커넥션 1과 커넥션 2는 사용 중이고 커넥션 3은 대기 중이라고 가정해보자.
새로운 요청 C가 새로운 데이터베이스 작업을 수행하려고 한다면, 사용 가능한 커넥션 3을 확보할 수 있다.
하지만 세 개의 커넥션이 모두 사용 중이라면 어떻게 될까 ?
새로운 요청은 커넥션이 반환될 때까지 기다려야 한다.
이때 중요한 것은 커넥션 풀이 모두 사용 중이라고 해서 새로운 요청이 즉시 실패하는 것은 아니라는 점이다.
커넥션을 확보하기 위한 대기 시간이 존재하며, 설정된 시간 안에 커넥션을 확보하지 못하면 타임아웃이 발생한다.
그렇다면 GitHub에서는 왜 커넥션이 모두 사용 중인 상황이 발생했을까 ?
3.3 장애 발생 원인
GitHub의 데이터베이스 커넥션 풀은 이미 높은 사용률을 보이고 있었다고 한다.
이때 일부 업데이트 요청이 예상보다 오랫동안 커넥션을 점유하면서 문제가 발생했다.
해당 요청은 데이터 변경 작업을 수행하는 과정에서 별도의 느린 조회를 실행하고 있었는데,
문제는 그 조회가 완료될 때까지 커넥션을 계속 점유하고 있었다는 점이다.
이러한 느린 조회 요청이 여러 개 동시에 발생하자 커넥션 풀이 고갈되었고, 다른 요청들은 사용 가능한 커넥션을 확보하지 못했다.
3.4 Spring Boot에서도 발생할 수 있을까
예를 들어 다음과 같은 코드가 있다고 가정해보자.
@Transactional
public void update(Long id) {
User user = userRepository.findById(id)
.orElseThrow();
user.updateStatus();
ExternalData data = externalApi.fetch();
user.updateExternalData(data);
}
위 코드는 트랜잭션 내부에서 사용자 정보를 조회하고 수정한 다음, 외부 API를 호출한다.
그런데 외부 API가 응답하는 데 5초가 걸린다면 어떻게 될까 ?
트랜잭션 내부에서 이미 커넥션을 확보했다면 외부 API 응답을 기다리는 동안에도 해당 커넥션을 점유한다.
데이터베이스에 특정 작업을 하지 않는 상태인데도 말이다.
특히 동시 요청이 많고 커넥션 풀의 여유가 적다면, 이러한 지연이 커넥션 풀 고갈로 이어질 수 있다.
3.5 해결 방법
가장 먼저 생각할 수 있는 방법은 커넥션 풀의 크기를 늘리는 것이다.
커넥션 풀의 크기를 늘리면 더 많은 요청이 동시에 작업을 수행할 수 있다.
하지만 이것이 항상 올바른 해결 방법은 아니다.
커넥션 수가 증가하면 데이터베이스 서버가 관리해야 하는 연결도 증가하고,
동시에 실행되는 쿼리의 수가 늘어나면서 데이터베이스에 더 큰 부하가 발생할 수 있다.
무엇보다 커넥션을 불필요하게 오래 점유하는 문제가 그대로 남아 있다면, 트래픽이 증가했을 때 동일한 장애가 다시 발생할 수 있다.
당장 눈앞에 닥친 문제를 해결할 순 있어도, 근본적인 해결 방법은 아니라는 것이다.
따라서 커넥션 풀의 크기를 늘리기 전에 왜 커넥션이 오래 점유되고 있는지 확인할 필요가 있다.
3.6 GitHub의 해결 방법
GitHub는 문제가 된 느린 조회 작업을 데이터 변경 작업보다 먼저 수행하도록 순서를 변경했다.
즉, 커넥션을 확보한 상태에서 느린 작업을 기다리는 상황 자체를 제거한 것이다.
아까의 예시도 비슷한 방식으로 개선할 수 있다.
@Service
@RequiredArgsConstructor
public class UserService {
private final ExternalApi externalApi;
private final UserUpdateService userUpdateService;
public void update(Long id) {
ExternalData data = externalApi.fetch();
userUpdateService.updateInTransaction(id, data);
}
}
@Service
@RequiredArgsConstructor
public class UserUpdateService {
private final UserRepository userRepository;
@Transactional
public void updateInTransaction(Long id, ExternalData data) {
User user = userRepository.findById(id)
.orElseThrow();
user.updateStatus();
user.updateExternalData(data);
}
}
외부 API 호출을 트랜잭션 밖으로 빼고, 실제 데이터베이스 변경 작업만 트랜잭션 내부에서 수행하도록 변경했다.
이렇게 하면 외부 API 응답을 기다리는 동안 커넥션을 불필요하게 점유하는 상황을 방지할 수 있다.
또한 GitHub는 하나의 요청이 커넥션을 지나치게 오래 점유하지 못하도록 제한하는 방안도 검토하고 있다고 한다.
이번 사례를 통해 커넥션 풀 고갈이 단순히 커넥션 수가 부족해서 발생하는 문제가 아니라는 것을 알 수 있있다.
커넥션을 얼마나 많이 확보할 수 있는지도 중요하겠지만, 확보한 커넥션을 얼마나 효율적으로 사용하고 반환하는지 역시 중요하다.
마치며
이번 GitHub 가용성 보고서를 읽으면서 대규모 서비스에서 발생하는 장애가 반드시 복잡한 기술적 결함에서만 발생하는 것은 아니라는 생각이 들었다.
오래된 라우팅 정보가 들어가거나, 재연결 시도가 너무 많던가, 커넥션 풀 고갈 등등 ,,,
특히 흥미로웠던 부분은 장애를 복구하기 위한 동작도 또 다른 장애의 원인이 될 수 있다는 점이었다.
재시도나 자동 복구가 항상 안전한 것만은 아니며, 정상적인 상황뿐 아니라 장애가 발생한 상황에서도 시스템이 어떻게 동작할지 고려해야 한다.
결국 안정적인 서비스를 개발하기 위해서는 정상적인 요청이 성공하는지만 확인하는 것이 아니라,
비정상적인 요청을 보냈을 때 어떻게 실패하는지, 어떤 방식으로 동작하는지까지 고민해봐야 할 것 같다.
사실 그러기 위해 있는 게 테스트 코드인데 ,,,,
평소엔 테스트 코드 짜는 게 너무 귀찮아서 대충 짜고 말거나 안 짰다 ㅎ
이제는 진짜 테스트 코드 작성하는 습관을 들여보겠다 ,,