13년차의 서버실

서버, 인프라, 홈랩 기술 블로그

[태그:] OpenStack

  • [OpenStack] RDO OpenStack 마이그레이션: DevStack에서 운영형 배포로 전환하기

    [OpenStack] RDO OpenStack 마이그레이션: DevStack에서 운영형 배포로 전환하기

    RDO OpenStack 마이그레이션: DevStack에서 운영형 배포로 전환하기

    RDO OpenStack 마이그레이션 이야기는 생각보다 많은 분들이 한 번쯤 부딪히는 주제입니다. 처음엔 DevStack(데브스택, OpenStack 개발·테스트용 빠른 배포 도구)으로 가볍게 올려 봤다가, 서비스가 붙고 VM이 늘고 네트워크가 꼬이기 시작하면 그때부터 고민이 깊어지거든요. 저도 홈랩에서 시작했다가 “이걸 계속 DevStack으로 끌고 가는 게 맞나?” 싶은 순간이 왔었습니다. 처음엔 이게 뭔가 싶었는데, 막상 하나씩 뜯어보니 핵심은 단순했습니다. 개발 편의 중심 환경을 운영형 구조로 바꾸는 일, 바로 그겁니다.

    특히 DevStack 프로덕션 전환을 고민하시는 분들이라면, 단순히 설치만 다시 하는 문제가 아니라 Nova(노바, 컴퓨트 서비스), Neutron(뉴트론, 네트워크 서비스), Glance(글랜스, 이미지 서비스), Cinder(신더, 블록 스토리지) 같은 구성요소를 어떻게 옮기고 검증할지까지 같이 봐야 합니다. 여기서 중요한 포인트! RDO는 Red Hat 계열 생태계에서 OpenStack 패키지를 다루기 편하게 제공하는 배포판 계열로 많이 이야기되기 때문에, DevStack 다음 단계의 후보로 자주 검토되더라고요.

    RDO OpenStack 마이그레이션 전체 아키텍처 개요 이미지

    DevStack 단일 또는 소규모 테스트 환경에서 RDO 기반 역할 분리 구조로 옮겨 가는 흐름을 한눈에 보여주는 이미지입니다.

    1. 왜 DevStack에서 RDO OpenStack으로 옮기게 되나

    쉽게 말해 DevStack은 빨리 띄워서 기능을 확인하는 데 최적화되어 있어요. 반대로 운영 관점에서는 아쉬운 부분이 꽤 보입니다. 서비스 재기동 순서, 설정 누적 관리, 패키지 일관성, 장기 운영 시 변경 추적 같은 부분에서요. 저도 처음엔 “테스트 잘 되는데 굳이?”라고 생각했는데, 장애를 두 번 겪고 생각이 바뀌었습니다 ㅎㅎ

    • DevStack: 빠른 실험, API 테스트, 기능 검증에 강점
    • RDO: 패키지 기반 운영, 구성 관리, 역할 분리 설계에 유리
    • 핵심 차이: 편의성 중심이냐, 운영 일관성 중심이냐죠

    특히 클라우드 환경 이전에서는 “서비스가 떠 있느냐”보다 “문제가 났을 때 추적 가능한가”가 더 중요합니다. 제가 직접 해보니, 이 시점부터는 설치 속도보다 운영 구조가 훨씬 중요해지더라고요.

    2. 개념부터 정리: DevStack과 RDO의 차이

    혹시 이런 경험 있으신가요? DevStack으로는 금방 Horizon(호라이즌, 웹 대시보드)까지 열리는데, 며칠 지나고 설정을 다시 손보려 하면 어디서 바꿨는지 기억이 안 나는 경우요. 저도 그랬거든요. 그래서 먼저 개념을 분리해서 봐야 합니다.

    항목 DevStack RDO OpenStack
    주된 목적 개발, 테스트, API 검증 운영형 배포와 패키지 기반 관리
    배포 방식 스크립트 중심 패키지 및 배포 도구 중심
    구성 관리 실험에 유리 역할 분리와 반복 배포에 유리
    추천 용도 랩, 학습, 기능 확인 장기 운영 검토, 표준화된 환경

    OpenStack 배포판 선택에서 중요한 건 “무엇이 더 고급이냐”가 아니에요. 내 환경에서 변경 관리와 장애 대응이 가능한가, 이 질문이 더 중요합니다. 쉽게 말해 DevStack은 ‘빨리 시작하는 도구’이고, RDO는 ‘운영 구조를 갖춰 가는 출발점’에 가깝습니다.

    3. 마이그레이션 전에 반드시 정리할 체크리스트

    여기서 바로 설치로 들어가면 삽질 확률이 꽤 높아요. 저는 이 단계를 가볍게 봤다가 네트워크 이름하고 브리지 매핑을 뒤엎는 바람에 시간을 좀 썼습니다. 드디어 됐다 싶었는데 인스턴스가 외부 통신이 안 되더라고요.

    1. 현재 리소스 인벤토리 작성: 인스턴스, 이미지, 볼륨, 플로팅 IP, 보안그룹 목록 정리
    2. 네트워크 설계 고정: Management(관리망), Provider(프로바이더망), Tenant(테넌트망) 구분
    3. 서비스 우선순위 지정: 어떤 워크로드를 먼저 옮길지 결정
    4. 다운타임 기준 수립: 이미지 기반 재배포인지, 데이터 복제인지 미리 확정
    5. 백업 확보: DB, 설정 파일, 이미지, 중요한 볼륨 스냅샷 확보

    아래처럼 최소한의 현황 수집 명령은 먼저 뽑아 두는 걸 권합니다.

    openstack service list
    openstack endpoint list
    openstack hypervisor list
    openstack server list --all-projects
    openstack image list
    openstack volume list --all-projects
    openstack network list
    openstack subnet list
    openstack router list
    openstack security group list

    이 출력 결과를 저장해 두면, 나중에 클라우드 환경 이전 검증할 때 비교 기준이 생깁니다. 이거 진짜 편하더라고요.

    4. 실전 구현 1: DevStack 환경 백업과 추출

    제가 실제로 먼저 했던 건 “새 환경 설치”가 아니라 “기존 환경을 최대한 읽을 수 있게 만드는 것”이었어요. 그래야 옮긴 뒤에 빠진 걸 찾을 수 있거든요.

    4-1. 설정 파일과 데이터 백업

    sudo mkdir -p /backup/devstack
    sudo cp -a /etc/nova /backup/devstack/
    sudo cp -a /etc/neutron /backup/devstack/
    sudo cp -a /etc/glance /backup/devstack/
    sudo cp -a /etc/cinder /backup/devstack/
    sudo mysqldump --all-databases > /backup/devstack/openstack-all.sql

    물론 실제 경로와 데이터베이스 접속 방식은 환경마다 다릅니다. 중요한 건 서비스 설정과 메타데이터를 같이 남겨 두는 것이에요.

    4-2. 이미지와 중요 리소스 추출

    mkdir -p ~/migration/images
    for id in $(openstack image list -f value -c ID); do
      name=$(openstack image show "$id" -f value -c name | tr ' ' '_')
      openstack image save --file ~/migration/images/${name}.qcow2 "$id"
    done

    볼륨 기반 워크로드는 더 신중해야 해요. 인스턴스 이미지로만 끝나는 게 아니라 애플리케이션 데이터 정합성까지 봐야 하니까요. 데이터베이스가 올라간 인스턴스라면 파일 복사 전에 서비스 정지나 스냅샷 정책을 꼭 정해 두셔야 합니다.

    RDO OpenStack 마이그레이션 준비 단계 백업 및 리소스 추출 이미지

    기존 DevStack에서 이미지, 설정, 데이터베이스 메타데이터를 백업하는 절차를 설명하는 이미지입니다.

    5. 실전 구현 2: RDO 설치와 운영형 구조 맞추기

    이제 RDO 설치 단계네요. 여기서는 “한 번에 완성”보다 “먼저 표준 구조를 세운다”가 중요합니다. 저는 처음에 all-in-one으로 빨리 띄우고 끝내려다가, 결국 역할 분리 구조를 다시 고민하게 됐어요. 그래서 테스트용과 운영형 설계를 분리해서 접근했습니다.

    5-1. 랩 검증용 배포 예시

    sudo dnf install -y openstack-packstack
    sudo packstack --allinone

    이 방식은 랩이나 기능 검증에는 편해요. 다만 운영형으로 가려면 Controller(컨트롤러), Compute(컴퓨트), Network(네트워크) 역할을 분리해서 보는 쪽이 낫습니다.

    5-2. 네트워크 설계 예시

    [network]
    management_interface=ens192
    provider_interface=ens224
    bridge_mappings=physnet1:br-ex
    external_network=public
    floating_ip_cidr=203.0.113.0/24

    위 예시는 개념 설명용이에요. 실제 인터페이스 이름과 대역은 환경에 맞게 바꾸셔야 합니다. 저도 처음엔 브리지 이름을 대충 맞췄다가 Neutron L3 에이전트가 제대로 붙지 않아서 한참 봤습니다.

    5-3. 기본 검증 명령

    openstack compute service list
    openstack network agent list
    openstack catalog list
    openstack hypervisor stats show

    이 단계에서 서비스 등록과 에이전트 상태가 깔끔하게 보이면 다음으로 넘어가도 돼요. 반대로 여기서 빨간불이 보이면, 워크로드부터 옮기지 마시고 구조부터 다시 점검하세요. 경험상 이 순서가 시간을 아낍니다.

    6. 주의사항과 트러블슈팅: 제가 실제로 막혔던 지점들

    RDO OpenStack 마이그레이션에서 제일 많이 막히는 건 화려한 기능이 아니라 기본값 차이에요. 진짜 별거 아닌 설정 하나 때문에 반나절이 날아가더라고요.

    6-1. ⚠️ Neutron 브리지 매핑 불일치

    DevStack에서는 자동으로 맞아 들어가던 부분이 RDO에서는 더 명시적으로 보여요. physnet 이름, OVS(오픈 브이스위치) 브리지, NIC 매핑이 안 맞으면 외부 통신이 바로 안 됩니다.

    • 증상: 플로팅 IP 연결은 되는데 외부 통신 실패
    • 확인 포인트: bridge_mappings, external bridge, provider network 설정
    • 해결: 물리 NIC와 브리지 연결을 다시 확인하고 에이전트 재기동

    6-2. ⚠️ 보안그룹과 메타데이터 접근 차이

    인스턴스는 떴는데 SSH가 안 붙는 경우, 의외로 보안그룹이 원인인 경우가 많아요. 메타데이터 서비스 경로도 같이 봐야 하고요.

    openstack security group rule list default
    openstack port list --server <SERVER_ID>
    ping -c 3 <FLOATING_IP>
    ssh -i ~/.ssh/id_rsa cloud-user@<FLOATING_IP>

    6-3. ⚠️ 이미지 포맷과 드라이버 기대값 차이

    Glance 이미지 자체는 옮겨졌는데 부팅이 실패하는 경우도 있었어요. 이럴 때는 이미지 속성, 디스크 포맷, 하이퍼바이저 기대값을 같이 확인해야 합니다.

    • qcow2인지 raw인지 확인
    • virtio 드라이버 지원 여부 확인
    • cloud-init(클라우드 이닛, 초기 설정 자동화) 동작 여부 확인

    저도 처음엔 “이미지만 있으면 끝 아닌가?” 했는데, 실제로 써보니까 인스턴스 부팅 옵션이 미묘하게 달라서 예상 외로 시간이 걸렸어요.

    RDO OpenStack 마이그레이션 후 네트워크와 서비스 점검 이미지

    RDO 환경에서 네트워크 브리지, 에이전트 상태, 서비스 정상 여부를 검증하는 장면을 보여주는 이미지입니다.

    7. 검증과 결과 확인: 옮긴 뒤 무엇을 봐야 하나

    운 좋게 인스턴스가 부팅됐다고 끝이 아니에요. 여기서부터가 진짜 검증입니다. 저는 아래 순서대로 확인했습니다.

    1. 서비스 상태 확인: API, 스케줄러, 네트워크 에이전트
    2. 테스트 인스턴스 생성: 신규 부팅이 되는지 확인
    3. 외부 통신 확인: 플로팅 IP, NAT, 보안그룹 확인
    4. 스토리지 검증: 볼륨 생성, 연결, 분리 테스트
    5. 이미지 재사용성 확인: 기존 백업 이미지로 재배포 테스트
    openstack server create \
      --flavor m1.small \
      --image test-image \
      --network private \
      --security-group default \
      test-vm
    
    openstack server list
    openstack console log show test-vm
    openstack floating ip create public

    검증이 끝나면 꼭 결과를 문서화해 두세요. 어떤 네트워크 이름을 썼는지, 어떤 보안그룹 규칙이 필요한지, 어떤 이미지가 정상 부팅되는지 남겨 두면 다음 노드 증설 때 훨씬 수월합니다. 이건 멘토링할 때도 늘 강조하는 부분이에요.

    🎉 개인적으로 가장 큰 성과는 “문제가 나도 어디를 봐야 하는지 감이 생겼다”는 점이었어요. DevStack에서는 빠르게 실험할 수 있었고, RDO 쪽으로 오면서 운영 기준선이 생겼습니다.

    RDO OpenStack 마이그레이션 완료 후 검증 결과 이미지

    인스턴스 생성, 네트워크 연결, 서비스 상태가 정상으로 확인된 결과 화면을 표현하는 이미지입니다.

    8. 정리와 FAQ: DevStack 프로덕션 전환 전에 꼭 생각할 점

    결론부터 말씀드리면, DevStack에서 RDO OpenStack으로 마이그레이션은 단순 재설치가 아니라 운영 철학을 바꾸는 작업에 가깝습니다. 빨리 띄우는 환경에서, 반복 가능하고 설명 가능한 환경으로 넘어가는 거죠. 저도 처음엔 헷갈렸는데, 기준을 딱 하나로 잡으니 훨씬 쉬웠어요. “이 구성이 다음 달에도 내가 설명할 수 있는가?” 바로 그 질문이에요.

    다음 글에서는 이미지 카탈로그 정리, 네트워크 설계 분리, 그리고 베어메탈 자원과 연동할 때 체크할 포인트도 다뤄볼 예정입니다. 이전 글에서 다뤘던 홈랩 네트워크 설계 글과 연결해서 보시면 더 이해가 잘 되실 겁니다.

    자주 묻는 질문

    • Q. DevStack을 그대로 운영에 써도 되나요?
      짧게 말씀드리면 권장하긴 어려워요. 테스트와 학습에는 정말 좋지만, 장기 운영과 변경 관리까지 생각하면 운영형 구조 검토가 필요하더라고요.
    • Q. RDO만이 정답인가요?
      아닙니다. 다만 Red Hat 계열 환경과 패키지 기반 운영을 선호한다면 좋은 후보가 됩니다. 결국 OpenStack 배포판 선택은 팀 역량과 운영 기준에 달렸어요.
    • Q. 다운타임 없이 이전할 수 있나요?
      워크로드 성격에 따라 다릅니다. 상태 저장 서비스는 별도 복제 전략이 필요하고, 무상태 워크로드는 이미지 기반 재배포가 비교적 수월해요.

    💡 마지막 팁 하나만 드리면, 처음부터 완벽하게 옮기려 하지 마세요. 제 경험상 제일 잘 되는 방법은 작은 서비스 하나를 끝까지 이전하고 검증한 뒤 패턴을 복제하는 방식이었어요.

    DevStack과 RDO의 차이, 이전 체크리스트, 검증 포인트를 한 장으로 정리한 요약 이미지입니다.

  • [OpenStack] OpenStack Magnum Kubernetes 운영: 6개월 회고와 교훈

    [OpenStack] OpenStack Magnum Kubernetes 운영: 6개월 회고와 교훈

    OpenStack Magnum Kubernetes 운영: 6개월 회고와 교훈

    OpenStack Magnum Kubernetes 조합으로 클러스터를 6개월 정도 운영해보면, 처음 기대했던 포인트와 실제 운영 포인트가 꽤 다르다는 걸 느끼게 됩니다. 저도 처음엔 'OpenStack 위에서 Kubernetes를 좀 더 쉽게 만들 수 있겠네?' 정도로 접근했는데, 막상 돌려보니 편한 부분은 분명했고 반대로 운영자가 꼭 알아야 하는 제약도 꽤 있더라고요. 특히 사내 프라이빗 클라우드나 홈랩처럼 OpenStack 자원이 이미 깔린 환경에서는 Magnum 사용 후기를 많이 찾게 되는데, 실제로는 설치보다 운영이 더 중요했습니다. 이번 글은 OpenStack Magnum Kubernetes 환경을 6개월 운용하면서 느낀 점, 부딪힌 문제, 그리고 어떤 팀에 잘 맞는지 차분하게 정리한 회고입니다.

    혹시 이런 경험 있으신가요? 클러스터는 금방 만들었는데 업그레이드, 노드 교체, 네트워크 연결, 외부 로드밸런서 연동에서 갑자기 난도가 확 올라가는 순간 말이죠. 저도 딱 그랬습니다. 생성이 끝났다고 안심했는데, 운영은 또 다른 문제더라고요.

    Magnum, OpenStack, Kubernetes 워커 노드와 로드밸런서 관계를 보여주는 전체 구성도입니다.

    OpenStack Magnum이 여전히 의미 있는 이유

    쉽게 말해 Magnum은 OpenStack에서 COE(Container Orchestration Engine) 클러스터를 프로비저닝하는 서비스입니다. 과거 문서에는 Mesos나 Swarm도 함께 언급됐지만, 최근 공식 문서 기준으로는 사실상 Kubernetes 중심으로 보는 편이 맞습니다. OpenStack을 이미 쓰고 있다면 가상머신 인프라를 따로 만들고 그 위에 수동으로 kubeadm을 올리는 대신, OpenStack API와 템플릿 기반으로 클러스터 생성 흐름을 어느 정도 표준화할 수 있다는 점이 장점이거든요.

    제가 직접 써보니 이 지점이 꽤 중요했습니다. 인프라 팀 입장에서는 Nova, Neutron, Cinder, Octavia 같은 OpenStack 리소스 운영 경험이 이미 있잖아요. Magnum은 그 위에서 Kubernetes 클러스터를 조금 더 OpenStack스럽게 관리하게 해줍니다. 다만 완전한 Managed Kubernetes처럼 기대하면 실망할 수 있습니다. 제 경험상 Magnum은 '운영을 없애주는 도구'라기보다 'OpenStack 친화적인 클러스터 생성 자동화 계층'으로 이해할 때 만족도가 높았습니다.

    OpenStack Magnum 핵심 개념: Magnum, Cluster Template, Heat

    처음엔 이 구조가 꽤 헷갈렸는데, 큰 그림을 이해하고 나면 훨씬 수월해집니다. 여기서 중요한 포인트는 Magnum이 혼자 모든 걸 하는 게 아니라는 점입니다.

    • Magnum: Kubernetes 같은 COE 클러스터를 생성하고 관리하는 OpenStack 서비스입니다.
    • Cluster Template: 어떤 이미지, 네트워크, 플러그인, 노드 사양으로 클러스터를 만들지 정의하는 청사진입니다.
    • Heat: 전통적인 Magnum 배포에서 실제 인프라 스택을 구성하는 오케스트레이션 계층입니다. 장애를 파고들다 보면 결국 Heat 이벤트를 보게 되더라고요.
    • BayModel: 과거 명칭입니다. 최신 문서와 운영 맥락에서는 보통 Cluster Template 기준으로 보면 됩니다.

    한 줄로 요약하면 이렇습니다. Magnum이 요청을 받고, Cluster Template을 참고해 OpenStack 자원을 만들고, 전통적인 드라이버 환경에서는 Heat가 실제 스택 생성을 수행하는 구조입니다. 참고로 최근 공식 문서에서는 Heat 기반 드라이버가 deprecated로 안내되고 있어서, 운영 중인 환경이 어떤 드라이버를 쓰는지도 꼭 확인해두는 게 좋습니다.

    구성 요소 역할 운영할 때 봐야 할 포인트
    Magnum 클러스터 생성/삭제 요청 처리 API 상태, 템플릿 파라미터, 사용 중인 드라이버
    Heat 스택 생성과 자원 오케스트레이션 이벤트 로그, 실패 리소스 추적
    Neutron/Octavia 네트워크와 로드밸런서 외부 연결, 서비스 노출, 포트/보안그룹
    Kubernetes 워크로드 스케줄링과 운영 노드 상태, CNI, Ingress, 스토리지

    시작 전에 체크했던 항목들

    Magnum 사용 후기에서 잘 안 보이는데, 실제로는 사전 점검이 절반입니다. 저도 처음엔 클러스터 생성 명령부터 쳤다가 네트워크랑 이미지 때문에 한참 돌아갔거든요.

    1. OpenStack 서비스 상태 확인
      Magnum만 살아 있어도 되는 게 아니라 Keystone, Nova, Neutron, Glance, Heat가 기본적으로 안정적이어야 합니다.
    2. Kubernetes용 이미지 준비
      이미지 이름보다 더 중요한 건 클러스터 드라이버 요구사항입니다. 최근 공식 문서 기준으로는 Kubernetes용 이미지의 os_distro 메타데이터가 드라이버와 맞아야 하고, 기본 예시는 Fedora CoreOS 계열을 전제로 설명합니다.
    3. 외부 네트워크와 DNS 설계
      API 접근, 노드 egress, 이미지 pull 경로를 미리 봐야 합니다.
    4. Load Balancer 정책 확인
      마스터 API 엔드포인트와 Service 노출 방식이 Octavia와 어떻게 연결되는지 미리 확인해야 합니다.
    5. 스토리지 전략 결정
      Cinder 연동 방식을 어떻게 가져갈지, 동적 볼륨 전략을 초반부터 쓸지 미리 정해두는 게 좋습니다.

    OpenStack Magnum으로 Kubernetes 클러스터 만들기

    이제 실전입니다. 아래 예시는 홈랩과 테스트 환경에서 자주 확인하던 흐름을 기준으로 정리했습니다. 다만 배포판, 드라이버, OpenStack 릴리스에 따라 옵션 이름이나 권장 이미지가 달라질 수 있습니다. 그래서 핵심은 명령어를 외우는 것보다 어떤 리소스를 먼저 확인해야 하는지를 잡는 데 있습니다.

    1. 기본 리소스 확인

    openstack coe service list
    openstack network list
    openstack subnet list
    openstack image list
    openstack flavor list
    openstack keypair list

    여기서 네트워크, 서브넷, 이미지, flavor, keypair가 실제로 준비되어 있는지 먼저 봅니다. 이거 안 보고 바로 템플릿 만들면 높은 확률로 다시 돌아오게 됩니다.

    2. Cluster Template 생성

    openstack coe cluster template create k8s-template \
      --coe kubernetes \
      --image fedora-coreos-k8s \
      --external-network public \
      --fixed-network private-net \
      --fixed-subnet private-subnet \
      --flavor m1.medium \
      --master-flavor m1.medium \
      --docker-storage-driver overlay2 \
      --network-driver flannel \
      --volume-driver cinder \
      --floating-ip-enabled \
      --master-lb-enabled

    여기서 실수가 가장 많이 나왔습니다. 특히 external-network, fixed-network, image 조합이 안 맞으면 생성이 중간에 터지더라고요. 처음엔 Magnum 문제인 줄 알았는데, 파고 들어가면 Neutron 설정이나 이미지 메타데이터 문제인 경우가 많았습니다. 이미지 이름은 예시일 뿐이고, 실제 환경에서는 해당 드라이버가 요구하는 이미지 속성을 꼭 확인하셔야 합니다.

    OpenStack Magnum Cluster Template과 Kubernetes 리소스 매핑 이미지

    Cluster Template이 네트워크, 이미지, 플레버, 로드밸런서와 연결되는 흐름을 설명하는 다이어그램입니다.

    3. 클러스터 생성

    openstack coe cluster create k8s-prod-like \
      --cluster-template k8s-template \
      --master-count 1 \
      --node-count 3 \
      --keypair mykey

    테스트 환경에서는 master-count와 node-count를 보수적으로 시작하는 게 좋습니다. 처음부터 크게 만들면 실패 원인도 커지고, 디버깅 비용도 같이 올라갑니다. 저는 1 control plane, 2~3 worker부터 시작해서 네트워크와 스토리지가 안정적인지 먼저 봤습니다.

    4. cluster config 가져와서 접속

    mkdir -p k8s-prod-like-config
    openstack coe cluster config k8s-prod-like --dir k8s-prod-like-config
    export KUBECONFIG=$(pwd)/k8s-prod-like-config/config
    kubectl get nodes
    kubectl get pods -A

    이 단계는 환경에 따라 조금 다릅니다. 어떤 환경에서는 eval $(openstack coe cluster config <cluster-name>) 형태로 바로 접속하기도 하고, 어떤 환경에서는 생성된 config 파일을 KUBECONFIG로 잡아 쓰는 식이 더 명확했습니다. 생성 직후에는 CNI가 아직 완전히 올라오지 않은 경우도 있으니 몇 분 정도 여유를 두고 확인하는 게 좋습니다.

    5. 간단한 워크로드 배포

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: demo-nginx
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: demo-nginx
      template:
        metadata:
          labels:
            app: demo-nginx
        spec:
          containers:
          - name: nginx
            image: nginx:stable
            ports:
            - containerPort: 80
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: demo-nginx
    spec:
      selector:
        app: demo-nginx
      ports:
      - port: 80
        targetPort: 80
      type: LoadBalancer
    kubectl apply -f demo-nginx.yaml
    kubectl get deploy,svc,pods

    이 단계에서 OpenStack Magnum Kubernetes 환경이 정말 내 환경에서 굴러가는지 감이 옵니다. Service가 외부 IP를 잘 받는지, Pod가 정상 스케줄링되는지, 노드 간 통신이 되는지까지 같이 볼 수 있거든요.

    6개월 운영하면서 좋았던 점

    장점은 분명합니다. 특히 인프라 팀이 OpenStack에 익숙할수록 체감이 큽니다.

    • 클러스터 생성 표준화: 템플릿 기반이라 환경 복제가 수월했습니다.
    • OpenStack 권한 체계와 잘 맞음: 프로젝트 단위 자원 분리가 익숙해서 운영 흐름이 덜 낯설었습니다.
    • 홈랩 실험에 좋음: kubeadm을 매번 손으로 치는 것보다 반복 실험이 편하더라고요.
    • 자원 가시성 확보: VM, 볼륨, 포트, 로드밸런서를 OpenStack 관점에서 같이 추적할 수 있었습니다.

    특히 여러 팀이 비슷한 Kubernetes 클러스터 운영 패턴을 가져가야 한다면 Cluster Template은 생각보다 강력합니다. 누가 만들어도 기본 뼈대가 크게 흔들리지 않거든요. 이건 실제로 꽤 편했습니다.

    운영하면서 부딪힌 문제와 트러블슈팅

    여기가 진짜 중요했습니다. OpenStack Magnum Kubernetes 글을 보면 설치 데모는 많아도, 운영 중 생기는 문제는 상대적으로 덜 보이더라고요. 그런데 결국 운영은 장애와 변경 관리 싸움이었습니다.

    1. 문제를 Kubernetes에서만 찾으면 늦습니다

    Pod가 안 뜨거나 Service 외부 노출이 안 되면 처음엔 kubectl만 보게 됩니다. 저도 그랬습니다. 그런데 실제 원인은 Heat 스택 실패, 보안그룹 규칙, Neutron 포트 상태, Octavia 리스너 문제인 경우가 적지 않았습니다.

    openstack stack list
    openstack stack resource list <stack-name>
    openstack stack event list <stack-name>

    여기서 중요한 포인트는 Magnum 장애 분석에는 Kubernetes와 OpenStack을 같이 보는 시야가 필요하다는 점입니다. 한쪽만 보면 원인을 놓치기 쉽습니다.

    2. 업그레이드 전략은 미리 정해야 합니다

    Kubernetes 클러스터 운영에서 가장 민감한 건 업그레이드입니다. Magnum이 있다고 해서 업그레이드가 마법처럼 쉬워지는 건 아니었습니다. 오히려 템플릿, 이미지, 애드온, CNI 버전 호환성을 같이 보게 되더라고요. 그래서 운영 중반부터는 '인플레이스 업그레이드에 집착하지 말고, 새 템플릿 기반 병행 클러스터를 검증한 뒤 전환하자' 쪽으로 사고를 바꿨습니다.

    조금 번거로워 보여도 결과적으로는 더 안전했습니다. 특히 사내 서비스나 장기 운영 워크로드가 얹힌 상태라면 더 그렇습니다.

    3. 네트워크 플러그인과 외부 노출은 가장 먼저 검증해야 합니다

    Ingress나 LoadBalancer 서비스가 기대대로 동작하지 않으면, 사용자 입장에서는 클러스터가 죽은 것처럼 보입니다. 실제로 써보니까 네트워크 드라이버와 OpenStack 네트워크 설계가 맞물리는 구간이 생각보다 까다로웠습니다.

    • Node 간 Pod 통신 확인
    • API 서버 접근 경로 확인
    • 외부 IP 할당 정책 확인
    • 보안그룹 인바운드/아웃바운드 확인

    처음엔 애플리케이션 문제인 줄 알았는데, 보안그룹 한 줄 빠진 거여서 허탈했던 적도 있습니다. 이런 삽질이 은근 많더라고요.

    4. 노드 장애 복구는 '재현 가능성'이 핵심입니다

    노드 하나가 망가졌을 때 수동 조치만으로 복구가 되면 당장은 편합니다. 그런데 그게 반복 가능하지 않으면 다음 장애 때 더 힘들어집니다. 저는 6개월 운영하면서 로그를 많이 남겼고, 결국에는 '노드 문제는 수동 응급조치보다 템플릿과 생성 절차 정비가 우선'이라는 결론을 내렸습니다.

    검증과 결과: 운영 기준으로 무엇을 확인했나

    클러스터가 떴다는 것과 운영 가능한 상태라는 것은 다릅니다. 저는 아래 순서로 검증했습니다.

    1. 노드 Ready 상태 확인
    2. CoreDNS, CNI, kube-proxy 같은 기본 시스템 Pod 확인
    3. LoadBalancer 서비스 외부 노출 확인
    4. Persistent Volume 동작 확인
    5. 재부팅 또는 노드 교체 후 상태 재확인
    kubectl get nodes
    kubectl get pods -A
    kubectl get svc -A
    kubectl get storageclass
    kubectl describe node <node-name>

    간단하지만 이 체크리스트가 꽤 유효했습니다. 6개월 동안 느낀 건, OpenStack Magnum Kubernetes 환경에서는 처음 생성 성공보다 반복 검증 성공이 훨씬 중요하다는 점입니다.

    OpenStack Magnum Kubernetes 클러스터 검증 결과 대시보드 이미지

    노드 Ready 상태, 시스템 Pod, 서비스 외부 IP 상태를 함께 보여주는 결과 확인 이미지입니다.

    운영 결과를 한 줄로 정리하면 이렇습니다. 소규모 프라이빗 클라우드나 내부 플랫폼 팀 환경에서는 충분히 의미가 있지만, 모든 운영 복잡도를 감춰주는 도구는 아니다. 이 기대치만 정확하면 꽤 만족스럽게 사용할 수 있습니다.

    어떤 환경에 잘 맞고, 어떤 경우엔 아쉬운가

    상황 Magnum 적합도 이유
    OpenStack 중심의 내부 인프라 팀 높음 기존 운영 지식과 연결되기 좋습니다.
    홈랩/검증 환경 높음 반복 생성과 실험에 유리합니다.
    완전관리형 서비스 기대 낮음 운영자가 알아야 할 영역이 여전히 넓습니다.
    빠른 버전 전환이 잦은 환경 중간 이미지, 템플릿, 네트워크 호환성 검증이 필요합니다.

    저도 처음엔 Magnum이 조금 더 많은 걸 알아서 해주길 기대했었습니다. 그런데 6개월 써보니 관점을 바꾸게 되더라고요. Magnum은 운영을 없애주는 도구가 아니라, OpenStack 안에서 Kubernetes 클러스터 운영의 출발점을 정리해주는 도구에 가깝습니다. 이 차이를 이해하면 만족도가 확 올라갑니다.

    OpenStack Magnum 도입 전후 Kubernetes 운영 방식 비교 이미지

    수동 kubeadm 방식과 Magnum 기반 운영 방식의 차이를 요약한 비교 인포그래픽입니다.

    정리와 다음 단계

    정리해보면, OpenStack Magnum으로 Kubernetes 클러스터 운영을 해보면서 얻은 교훈은 꽤 명확했습니다.

    • Magnum은 생성 자동화에 강점이 있습니다.
    • 운영 문제는 결국 OpenStack과 Kubernetes를 함께 봐야 풀립니다.
    • 업그레이드와 네트워크 검증은 초반 설계 단계에서 방향을 잡아야 덜 힘듭니다.
    • 작게 시작해서 반복 검증하는 방식이 가장 현실적이었습니다.

    지금 OpenStack 기반으로 클라우드 네이티브 환경을 고민하고 계시다면 Magnum은 충분히 검토할 만한 선택지입니다. 다만 Managed Kubernetes처럼 생각하면 실망할 수 있고, OpenStack 친화적인 클러스터 프로비저닝 계층으로 이해하면 훨씬 잘 맞습니다. 관련해서 이전에 정리한 OpenStack 네트워크 기본기 글이나 스토리지 구성 글도 함께 보면 이해가 훨씬 빨라집니다.

    다음 글에서는 이번 회고에서 살짝 언급했던 Ingress 구성, Cinder 기반 스토리지 연결, 그리고 운영 중 모니터링 포인트를 따로 묶어서 정리해보려 합니다. 이어서 보면 실제 운영 흐름이 더 선명하게 보이실 거예요.

    자주 묻는 질문 FAQ

    Magnum이 있으면 Kubernetes 운영이 쉬워지나요?

    일부는 맞고, 일부는 아닙니다. 클러스터 생성과 표준화는 확실히 편해집니다. 하지만 장애 분석, 네트워크, 업그레이드 전략은 여전히 운영자의 몫입니다.

    Magnum과 kubeadm 중 무엇이 더 낫나요?

    OpenStack 환경 표준화가 중요하면 Magnum이 편합니다. 반대로 세밀한 수동 제어가 더 중요하고 OpenStack 통합이 핵심이 아니라면 kubeadm 쪽이 더 단순하게 느껴질 수도 있습니다.

    6개월 운영 기준으로 가장 먼저 챙길 것은 무엇인가요?

    네트워크와 업그레이드 전략입니다. 이 두 가지를 초반에 대충 잡으면 나중에 운영 피로도가 크게 올라갑니다.

  • [OpenStack] DevStack 환경에서 OpenStack 서비스 간 연동 문제 해결 가이드

    [OpenStack] DevStack 환경에서 OpenStack 서비스 간 연동 문제 해결 가이드

    DevStack 환경에서 OpenStack 서비스 간 연동 문제 해결 가이드

    DevStack OpenStack 연동 문제는 생각보다 자주 만납니다. 설치는 얼추 끝난 것 같은데 인스턴스가 안 뜨고, 네트워크가 안 붙고, 이미지 조회는 되는데 부팅은 실패하고, 로그를 보면 Keystone(키스톤, 인증 서비스) 쪽 인증 에러가 한 줄씩 튀어나오거든요. 저도 홈랩에서 개발 환경을 구성하면서 이런 삽질을 꽤 했더라고요. 처음엔 서비스가 각각 살아 있으면 되는 줄 알았는데, 실제로는 서비스 간 엔드포인트(endpoint, 접속 지점), 메시지 큐(message queue), 데이터베이스(database), 서비스 사용자(service user) 권한이 한 군데만 어긋나도 전체 흐름이 무너집니다.

    이번 글은 제품 홍보나 이론 소개가 아니라, 제가 직접 DevStack 개발 환경에서 반복적으로 겪었던 OpenStack 서비스 연동 문제를 어떤 순서로 확인하고 풀었는지 정리한 실전형 트러블슈팅 가이드입니다. 혹시 DevStack 트러블슈팅 하다가 로그만 한참 보고 계셨다면, 이 순서대로 점검해 보시면 시간 꽤 아끼실 수 있을 겁니다.

    Keystone, Nova, Neutron, Glance, Cinder가 DevStack 환경에서 어떻게 연결되는지 한눈에 보여주는 개요 이미지입니다.

    1. 왜 DevStack 개발 환경에서 OpenStack 서비스 연동 문제가 자주 생길까

    쉽게 말해 DevStack은 빠르게 OpenStack을 올려서 개발과 검증을 하기 위한 환경입니다. 그래서 편한 점도 많지만, 반대로 서비스가 많고 연결 지점도 많습니다. 예를 들어 Nova(노바, 컴퓨트 서비스)가 인스턴스를 띄우려면 Keystone에서 토큰 인증을 받고, Glance(글랜스, 이미지 서비스)에서 이미지를 읽고, Neutron(뉴트론, 네트워크 서비스)에서 포트를 만들고, 필요하면 Cinder(신더, 블록 스토리지)까지 붙어야 하거든요.

    즉, 화면에서 보이는 실패 증상은 하나인데 원인은 여러 군데일 수 있습니다. 여기서 중요한 포인트! 증상 기준으로 보지 말고 요청 흐름 기준으로 봐야 빨리 잡힙니다. 저도 처음엔 Horizon(호라이즌, 대시보드)에서 에러만 보고 있었는데, 실제 원인은 RabbitMQ(래빗MQ, 메시지 브로커) 연결 문제였던 적도 있더라고요.

    2. OpenStack 서비스 연동을 흐름으로 이해하기

    OpenStack 서비스 연동을 너무 어렵게 볼 필요는 없습니다. 요청 하나가 아래처럼 지나간다고 생각하시면 됩니다.

    1. 사용자 또는 CLI가 Keystone에 인증 요청을 보냅니다.
    2. 인증이 끝나면 서비스 카탈로그(service catalog, 서비스 목록)와 토큰을 받습니다.
    3. Nova가 Glance, Neutron, Placement 같은 다른 서비스와 통신합니다.
    4. 백엔드에서는 메시지 큐와 데이터베이스가 중간 연결을 받쳐줍니다.
    5. 문제가 생기면 API 응답, 서비스 로그, 백엔드 연결 상태 중 하나가 어긋납니다.
    구성 요소 역할 연동 실패 시 흔한 증상
    Keystone 인증/권한/엔드포인트 관리 401 Unauthorized, endpoint not found
    Nova 가상머신 생성 및 제어 인스턴스 build 실패, scheduling 오류
    Neutron 네트워크/포트/IP 관리 포트 생성 실패, floating IP 연결 불가
    Glance 이미지 저장 및 조회 이미지 다운로드 실패, boot from image 오류
    Cinder 볼륨 제공 볼륨 attach 실패, device not found

    이 표만 머리에 넣어도 DevStack OpenStack 연동 문제를 볼 때 훨씬 덜 막막합니다. 사실 로그를 읽는 요령도 결국은 어느 서비스가 다음 서비스를 못 찾고 있는지를 보는 거거든요.

    3. DevStack 트러블슈팅 전에 먼저 확인할 기본 체크리스트

    본격적으로 로그 보기 전에, 저는 아래 항목부터 먼저 봅니다. 사소해 보여도 여기서 많이 걸립니다.

    • 호스트명과 IP: 서비스가 등록된 주소와 실제 바인딩 주소가 같은지
    • /etc/hosts: 로컬 이름 해석이 꼬이지 않았는지
    • 시스템 시간: 토큰 인증 문제를 만들 정도로 시간 차이가 없는지
    • 포트 리스닝 상태: 각 API 서비스가 실제로 떠 있는지
    • 환경 변수: admin-openrc 같은 OpenRC 파일을 제대로 불러왔는지

    제가 직접 해보니, OpenRC를 안 읽은 상태에서 CLI 테스트를 해서 Keystone 문제로 착각한 경우가 제일 허무했습니다. 드디어 원인 찾았다 싶었는데 그냥 환경 변수 누락이더라고요.

    cd ~/devstack
    source openrc admin admin
    openstack token issue
    openstack service list
    openstack endpoint list
    

    위 명령이 정상 동작하면 최소한 Keystone 인증과 서비스 카탈로그 조회는 된다는 뜻입니다. 여기서부터 하나씩 좁혀가면 됩니다.

    4. 실전 구현: DevStack 환경에서 서비스 연동 상태 점검 순서

    4-1. DevStack 설정 파일부터 다시 봅니다

    local.conf에 서비스 활성화가 빠져 있거나, 비밀번호 변수 구성이 엇갈리면 설치는 돼도 연동이 흔들립니다. 아래는 가장 기본적인 예시입니다.

    [[local|localrc]]
    ADMIN_PASSWORD=secret
    DATABASE_PASSWORD=$ADMIN_PASSWORD
    RABBIT_PASSWORD=$ADMIN_PASSWORD
    SERVICE_PASSWORD=$ADMIN_PASSWORD
    HOST_IP=192.168.56.10
    
    ENABLED_SERVICES=g-api,g-reg,key,n-api,n-cpu,n-cond,n-sch,n-novnc,q-svc,q-agt,q-dhcp,q-l3,q-meta,placement-api,c-api,c-bak,c-sch,horizon
    

    여기서 중요한 건 비밀번호를 단순하게 맞추라는 의미가 아니라, DevStack이 기대하는 변수 간 일관성을 유지하라는 겁니다. 실제 운영 환경에서는 당연히 더 엄격하게 관리해야 하고요.

    4-2. 서비스 프로세스와 API 포트를 확인합니다

    서비스 연동 오류처럼 보여도 실제로는 프로세스가 죽어 있는 경우가 꽤 많습니다.

    sudo systemctl --type=service | grep -E 'apache2|mariadb|mysql|rabbitmq'
    ss -lntp | grep -E '5000|8774|9292|9696|8776'
    ps -ef | grep -E 'nova|neutron|glance|keystone' | grep -v grep
    

    포트 기준으로 보면 보통 다음을 많이 확인합니다.

    • 5000: Keystone API
    • 8774: Nova API
    • 9292: Glance API
    • 9696: Neutron API
    • 8776: Cinder API
    DevStack OpenStack 연동 문제 점검을 위한 local.conf 설정 구성 이미지

    DevStack 설정 파일과 활성화된 OpenStack 서비스가 어떤 관계로 연결되는지 보여주는 설명 이미지입니다.

    4-3. 서비스 카탈로그와 엔드포인트를 검증합니다

    OpenStack 서비스 연동에서 진짜 자주 문제를 만드는 게 endpoint입니다. 서비스는 살아 있는데 잘못된 URL을 보고 있으면 호출이 실패합니다.

    openstack service list
    openstack endpoint list --long
    openstack catalog list
    

    여기서 체크할 건 단순합니다.

    1. Keystone에 각 서비스가 등록되어 있는지
    2. public, internal, admin URL이 비정상 주소를 가리키지 않는지
    3. 호스트명과 IP가 현재 DevStack 환경과 일치하는지

    특히 예전에 스냅샷이나 VM 복제로 실험 환경을 다시 만들었을 때, 예전 IP가 남아 있어서 삽질 좀 했습니다. 겉으론 다 살아 있는데 실제 호출은 엉뚱한 주소로 나가더라고요.

    4-4. 서비스별 실제 호출을 해봅니다

    CLI 목록 조회가 된다고 끝이 아닙니다. 진짜 연동이 되는지 보려면 서비스별로 최소 기능을 직접 호출해야 합니다.

    openstack image list
    openstack network list
    openstack flavor list
    openstack server list
    openstack volume service list
    

    그리고 가능하면 테스트용 네트워크와 인스턴스 생성까지 확인합니다.

    openstack network create demo-net
    openstack subnet create demo-subnet --network demo-net --subnet-range 10.10.0.0/24
    openstack router create demo-router
    openstack router add subnet demo-router demo-subnet
    

    이 단계에서 Neutron이 꼬여 있으면 바로 드러납니다. DevStack 트러블슈팅은 결국 조회 성공보다 생성/변경 요청 성공이 더 중요하더라고요.

    5. ⚠️ 실제로 많이 만나는 OpenStack 서비스 연동 문제와 해결법

    5-1. Keystone 인증은 되는데 Nova 인스턴스 생성이 실패하는 경우

    증상은 보통 인스턴스가 ERROR 상태로 떨어집니다. 이럴 때는 Nova 로그와 scheduler 흐름을 먼저 봅니다.

    sudo journalctl -u devstack@n-api -n 100 --no-pager
    sudo journalctl -u devstack@n-cpu -n 100 --no-pager
    sudo journalctl -u devstack@n-sch -n 100 --no-pager
    

    제가 자주 본 원인은 아래 셋입니다.

    • Glance 이미지 조회 실패
    • Neutron 포트 생성 실패
    • Placement 자원 조회 실패

    즉 Nova 자체 문제처럼 보여도 실제로는 다른 서비스 연동 이슈인 경우가 많습니다.

    5-2. Neutron 네트워크는 보이는데 포트 생성이 안 되는 경우

    이건 Linux bridge나 Open vSwitch 같은 네트워크 백엔드 구성과 에이전트 상태를 함께 봐야 합니다. DevStack에서는 설치가 끝났어도 에이전트가 비정상 상태일 때가 있습니다.

    openstack network agent list
    sudo journalctl -u devstack@q-svc -n 100 --no-pager
    sudo journalctl -u devstack@q-agt -n 100 --no-pager
    

    Alive 상태가 XXX 로 보이면, 네트워크 에이전트가 컨트롤 플레인과 정상 통신하지 못하는 경우가 많습니다. 여기서 중요한 포인트는 API만 보지 말고 에이전트 헬스까지 같이 봐야 한다는 점입니다.

    5-3. Glance 이미지 목록은 보이는데 부팅만 실패하는 경우

    처음엔 이게 뭔가 싶었는데, 이미지 메타데이터나 다운로드 경로 문제일 때가 있었습니다. 이미지가 등록됐다고 해서 실제 boot path가 정상이라는 뜻은 아니거든요.

    openstack image show cirros
    sudo journalctl -u devstack@g-api -n 100 --no-pager
    

    여기서는 이미지 상태가 active 인지, 접근 권한 문제는 없는지, Nova가 해당 이미지를 실제 읽을 수 있는지 확인합니다.

    5-4. RabbitMQ 또는 DB 연결 문제로 서비스가 간헐적으로 실패하는 경우

    이건 더 골치 아픕니다. 같은 명령이 한 번은 되고 한 번은 안 되거든요. 저도 실제로 써보니까 간헐 장애는 오히려 더 찾기 어렵더라고요.

    sudo systemctl status rabbitmq-server
    sudo systemctl status mariadb
    sudo journalctl -u rabbitmq-server -n 100 --no-pager
    

    메시지 큐나 DB 연결이 흔들리면 각 서비스 로그에 timeout, reconnect, access denied 같은 메시지가 섞여 나옵니다. 이럴 때는 개별 서비스보다 공통 백엔드부터 의심하는 게 빠릅니다.

    DevStack 트러블슈팅 과정에서 OpenStack 서비스 연동 로그를 분석하는 이미지

    여러 OpenStack 서비스 로그를 비교해서 장애 지점을 추적하는 실제 운영 감각의 트러블슈팅 이미지입니다.

    6. 검증: 어디까지 확인해야 진짜 해결된 걸까

    로그 한 줄 없어졌다고 끝난 건 아닙니다. 저는 아래 순서가 모두 통과하면 그제야 해결로 봅니다.

    1. 토큰 발급이 정상 동작한다.
    2. 서비스 목록과 엔드포인트가 정상 조회된다.
    3. 이미지, 네트워크, 플래버 목록 조회가 된다.
    4. 테스트 네트워크와 서브넷 생성이 된다.
    5. 테스트 인스턴스가 ACTIVE 또는 기대 상태로 전환된다.
    6. 필요 시 floating IP 연결 또는 콘솔 접속이 된다.
    openstack token issue
    openstack endpoint list
    openstack network list
    openstack subnet list
    openstack image list
    openstack server create --flavor m1.tiny --image cirros --network demo-net test-vm
    openstack server list
    openstack console url show test-vm
    

    이 단계까지 가면 DevStack OpenStack 연동 문제는 대부분 정리됩니다. 물론 테스트 이미지나 플래버는 환경에 따라 다를 수 있으니, 현재 설치 상태에 맞게 조정하시면 됩니다.

    서비스 연동이 정상화된 뒤 CLI와 대시보드에서 인스턴스, 네트워크, 이미지가 모두 보이는 결과 이미지입니다.

    7. 빠른 진단 기준

    증상 먼저 볼 곳 우선 점검 포인트
    401 인증 오류 Keystone OpenRC, 토큰, 서비스 사용자 비밀번호
    인스턴스 생성 실패 Nova Glance/Neutron/Placement 연동
    포트 생성 실패 Neutron agent 상태, 브리지 구성, endpoint
    이미지 부팅 실패 Glance 이미지 상태, 접근 권한, API 응답
    간헐적 timeout RabbitMQ/DB 공통 백엔드 연결 안정성

    이 표는 제가 실제로 자주 참고하는 기준입니다. 독자분들도 로그를 보기 전에 먼저 증상별 1차 의심 지점을 잡아두면 훨씬 덜 헤매실 겁니다.

    8. 자주 묻는 질문과 실무 팁

    Q1. 서비스가 모두 떠 있는데도 왜 연동이 안 될까요?

    A. 프로세스가 떠 있는 것과 API 호출이 성공하는 것은 다릅니다. endpoint 등록, 권한, 환경 변수, 에이전트 상태를 같이 보셔야 합니다.

    Q2. DevStack을 다시 설치하는 게 더 빠를 때도 있나요?

    A. 있습니다. 특히 실험을 여러 번 반복하면서 설정이 꼬였을 때는 부분 수정보다 재구성이 빠를 때가 있더라고요. 다만 그 전에 왜 꼬였는지를 한 번 정리해 두면 다음부터 훨씬 빨라집니다.

    Q3. 로그는 어디부터 봐야 하나요?

    A. 사용자 요청이 처음 닿는 지점부터 보는 게 좋습니다. 예를 들어 인스턴스 생성 실패면 Nova API부터 보고, 그 다음 Neutron/Glance 쪽 연동 로그를 따라가는 방식이 효율적입니다.

    • 💡 팁: CLI 테스트는 Horizon보다 원인 분리가 쉽습니다.
    • 💡 팁: 한 번에 여러 문제를 고치지 말고, 한 항목씩 검증하세요.
    • 💡 팁: 변경 전 endpoint 목록과 서비스 상태를 저장해 두면 비교가 편합니다.
    DevStack OpenStack 연동 문제 해결 체크리스트 인포그래픽

    인증, 네트워크, 이미지, 인스턴스 생성 문제를 어떤 순서로 점검할지 한 장으로 정리한 요약 인포그래픽입니다.

    9. 마무리: DevStack 트러블슈팅의 핵심은 흐름을 보는 눈입니다

    이번 글에서는 DevStack OpenStack 연동 문제를 단순히 에러 메시지별로 보는 대신, 서비스 요청 흐름 기준으로 점검하는 방법을 정리해 봤습니다. 저도 처음엔 서비스 이름이 너무 많아서 겁부터 났었는데, 실제로는 Keystone, Nova, Neutron, Glance, Cinder가 어떻게 이어지는지만 잡아도 절반은 해결되더라고요.

    정리하면 이렇습니다. 인증이 되는지 확인하고, 엔드포인트가 맞는지 보고, 서비스별 실제 생성 요청을 날려보고, 공통 백엔드까지 확인한다. 이 순서가 DevStack 트러블슈팅에서 꽤 강력합니다. 다음 글에서는 DevStack 환경에서 Neutron 네트워크를 조금 더 깊게 파서, 브리지 구성과 외부 네트워크 연결 쪽도 따로 다뤄볼 예정입니다. 이전 글에서 다뤘던 OpenStack 기본 구성 이해 편이 있으시다면 같이 보시면 흐름 잡는 데 더 도움이 될 겁니다.

    혹시 지금 비슷한 OpenStack 서비스 연동 문제를 겪고 계시다면, 오늘 소개한 체크리스트만 따라가도 원인 범위를 꽤 빨리 좁히실 수 있을 겁니다. 드디어 됐다! 하는 순간이 분명 오거든요. 그 맛에 또 홈랩 만지게 됩니다 ㅎㅎ

  • [OpenStack] OpenStack Nova 성능 최적화: CPU 스케줄링 및 리소스 할당 분석

    [OpenStack] OpenStack Nova 성능 최적화: CPU 스케줄링 및 리소스 할당 분석

    [OpenStack] OpenStack Nova 성능 최적화: CPU 스케줄링 및 리소스 할당 분석

    OpenStack Nova 성능 최적화 이야기는 결국 운영하면서 한 번쯤 꼭 부딪히는 문제로 이어집니다. 가상 머신은 충분히 띄웠는데, 어떤 인스턴스는 반응이 빠르고 어떤 인스턴스는 같은 flavor(플레이버, 가상 머신 자원 정의)인데도 체감 성능이 들쭉날쭉하거든요. 저도 처음엔 “스토리지가 느린가?” 하고 엉뚱한 데를 먼저 봤었는데, 실제로 파고 들어가 보니 Nova CPU 스케줄링과 리소스 할당 방식이 병목의 핵심인 경우가 많았습니다. 특히 benchmark(벤치마크, 성능 측정) 결과를 비교할 때 CPU 오버커밋(overcommit, 실제 물리 자원보다 더 많이 논리 할당)과 NUMA(Non-Uniform Memory Access, 메모리 접근 거리가 다른 구조) 인식 여부가 결과를 꽤 크게 흔들더라고요.

    이번 글에서는 제가 홈랩과 테스트 환경에서 반복적으로 확인했던 관찰 포인트를 기준으로, OpenStack Nova 성능 최적화를 어디서부터 봐야 하는지 정리해보겠습니다. 숫자를 지어내거나 과장된 벤치마크를 보여드리기보다는, 무엇을 설정하고 무엇을 검증해야 재현 가능한 성능 분석이 되는지에 초점을 맞추겠습니다.

    Nova 스케줄러와 컴퓨트 노드, 하이퍼바이저, NUMA 토폴로지 관계를 한눈에 보여주는 개요 이미지입니다.

    1. 왜 OpenStack Nova 성능 최적화가 생각보다 까다로운가

    쉽게 말해 Nova는 “가상 머신을 어디에 올릴지”만 결정하는 도구가 아닙니다. CPU pinning(피닝, vCPU를 특정 pCPU에 고정), emulator thread(에뮬레이터 스레드), huge page(휴즈페이지, 큰 메모리 페이지), NUMA topology(토폴로지, 자원 배치 구조) 같은 요소가 다 엮여 있습니다. 그래서 표면적으로는 인스턴스 생성이 잘 되더라도, 실제 가상 머신 성능은 스케줄링 정책에 따라 크게 달라질 수 있습니다.

    제가 직접 해보니 가장 흔한 착각은 이겁니다. “vCPU 개수만 맞으면 성능도 비슷하겠지”라는 생각이요. 근데 현실은 그렇지 않더라고요. 같은 4 vCPU 인스턴스라도 어느 소켓(socket, CPU 패키지) 위에 배치됐는지, 이웃한 워크로드가 얼마나 시끄러운지(noisy neighbor, 자원 경쟁을 유발하는 인접 워크로드), CPU 공유 정책이 어떤지에 따라 결과가 달라집니다.

    • CPU overcommit ratio가 높으면 밀도는 올라가지만 지연 시간이 튈 수 있습니다.
    • Dedicated CPU policy를 쓰면 예측 가능성은 좋아지지만 수용량은 줄어듭니다.
    • NUMA mismatch가 나면 메모리 접근 비용이 늘어나 체감 성능이 떨어질 수 있습니다.
    • Benchmark 결과는 테스트 시간대와 이웃 인스턴스 상태에 따라서도 흔들립니다.

    2. Nova CPU 스케줄링 개념, 쉽게 말해 이런 구조입니다

    여기서 중요한 포인트! Nova CPU 스케줄링은 단순한 라운드로빈(round-robin, 순환 배치)이 아닙니다. 스케줄러는 호스트 필터(filter, 후보 선별 규칙)와 weighers(가중치 계산기)를 사용해서 컴퓨트 노드를 고릅니다. 그 다음 실제 하이퍼바이저 계층에서 vCPU와 pCPU 관계가 정해지죠.

    2-1. Shared CPU와 Dedicated CPU 차이

    구분 설명 장점 주의점
    Shared CPU 여러 VM이 물리 CPU 시간을 공유 집적도 높음 성능 편차 가능
    Dedicated CPU 특정 pCPU를 인스턴스에 고정 할당 예측 가능한 성능 운영 유연성 감소
    CPU Pinning vCPU를 지정 코어에 매핑 지터 감소 NUMA 설계 필요

    실제로 써보니까 데이터베이스나 NFV(Network Functions Virtualization, 네트워크 기능 가상화)처럼 지연 시간에 민감한 워크로드는 Shared CPU보다 Dedicated CPU 쪽이 훨씬 해석하기 편했습니다. 반대로 일반 웹 애플리케이션은 적당한 오버커밋이 더 경제적일 때가 많았고요.

    2-2. 리소스 할당에서 꼭 같이 봐야 할 요소

    • vCPU allocation ratio: 논리적으로 얼마나 더 많이 잡을지
    • RAM allocation ratio: 메모리 과할당 정책
    • Reserved host memory: 호스트 OS와 에이전트가 쓸 여유 공간
    • NUMA affinity: CPU와 메모리 지역성 유지
    • Huge pages: TLB 부담 감소에 유리

    저도 처음엔 헷갈렸는데, CPU만 최적화하면 끝이 아니더라고요. 메모리 배치가 틀어지면 CPU pinning을 해도 기대만큼 안 나오는 경우가 있습니다.

    3. 실전 기준선 만들기: benchmark 전에 먼저 해야 할 것

    OpenStack Nova 성능 최적화를 하겠다고 바로 설정부터 바꾸면 나중에 비교가 안 됩니다. 삽질 좀 했습니다 ㅎㅎ 결국 가장 먼저 해야 하는 건 기준선(baseline, 비교 기준)을 만드는 일입니다.

    1. 테스트 대상 flavor를 고정합니다.
    2. 테스트용 이미지와 커널 상태를 동일하게 맞춥니다.
    3. 동일한 시간대에 반복 실행합니다.
    4. 가능하면 noisy neighbor 영향을 줄인 별도 호스트를 씁니다.
    5. 인스턴스 내부 지표와 호스트 지표를 같이 수집합니다.

    제가 권장하는 최소 수집 항목은 아래 정도입니다.

    # Compute node
    lscpu
    numactl --hardware
    virsh vcpuinfo INSTANCE_DOMAIN
    virsh emulatorpin INSTANCE_DOMAIN
    virsh dumpxml INSTANCE_DOMAIN
    
    # Guest VM
    grep -E 'processor|physical id|core id' /proc/cpuinfo
    lscpu
    uptime
    mpstat -P ALL 1 5
    

    이 정도만 모아도 “스케줄링은 잘 됐는지”, “게스트가 기대한 토폴로지를 보고 있는지” 정도는 꽤 빨리 감이 옵니다.

    4. Nova CPU 스케줄링 설정 확인 포인트

    이제 본론입니다. Nova CPU 스케줄링과 리소스 할당을 볼 때 저는 보통 nova.conf의 CPU 정책부터 확인합니다. 환경마다 값은 다를 수 있지만, 아래와 같은 항목들이 자주 등장합니다.

    [DEFAULT]
    cpu_allocation_ratio=4.0
    ram_allocation_ratio=1.0
    reserved_host_memory_mb=4096
    
    [compute]
    cpu_shared_set=2-15
    cpu_dedicated_set=16-31
    
    [libvirt]
    virt_type=kvm
    emulator_threads_policy=share
    

    위 예시는 구조 설명용입니다. 특정 값이 정답이라는 뜻은 아닙니다. 다만 운영 의도는 분명해야 합니다. 예를 들어 cpu_shared_set와 cpu_dedicated_set를 섞어서 쓴다면, 어떤 워크로드를 공유형으로 둘지, 어떤 워크로드를 전용형으로 둘지 먼저 정해야 하거든요.

    중요한 건 설정 파일의 숫자보다 정책 일관성입니다. 한 호스트는 전용 CPU 정책, 다른 호스트는 공유 정책인데 같은 aggregate(집합, 스케줄링 그룹)로 묶여 있으면 benchmark 결과가 해석 불가능해질 수 있습니다.

    OpenStack Nova 성능 최적화 설정에서 CPU 정책과 NUMA 배치를 설명하는 이미지

    공유 CPU 세트, 전용 CPU 세트, 에뮬레이터 스레드 정책이 어떻게 나뉘는지 보여주는 설정 이미지입니다.

    5. 리소스 할당 전략: 워크로드별로 다르게 가져가야 합니다

    이 부분이 현업에서 진짜 중요합니다. 모든 인스턴스에 같은 정책을 적용하면 편하긴 한데, 성능과 밀도 둘 다 애매해지기 쉽습니다.

    5-1. 일반 웹/배치 워크로드

    • Shared CPU 기반 운영이 보통 효율적입니다.
    • 적절한 오버커밋으로 집적도를 높일 수 있습니다.
    • 대신 benchmark는 피크 시간과 비피크 시간을 나눠 봐야 합니다.

    5-2. DB, 메시지 큐, 지연 민감 서비스

    • Dedicated CPU 또는 CPU pinning 검토가 필요합니다.
    • NUMA 정렬과 huge page를 함께 보는 편이 좋습니다.
    • 가상 머신 성능 비교 시 평균값보다 tail latency(꼬리 지연)를 더 중시해야 합니다.

    5-3. 혼합 클러스터 운영 팁

    제 경험상 host aggregate(호스트 애그리게이트)와 flavor extra spec(플레이버 추가 속성)을 같이 쓰는 방식이 운영 설명력이 좋았습니다. 예를 들면 성능형 호스트 풀과 일반형 호스트 풀을 나누고, 성능형 flavor만 전용 CPU 정책으로 보내는 식이죠.

    openstack flavor set perf.large \
      --property hw:cpu_policy=dedicated \
      --property hw:mem_page_size=large
    
    openstack flavor set general.medium \
      --property hw:cpu_policy=shared
    

    이렇게 해두면 나중에 문제 생겼을 때 추적이 쉬워집니다. “왜 이 인스턴스는 빠르지?” 혹은 “왜 이건 느리지?”를 설명할 근거가 남거든요.

    6. ⚠️ 실제로 자주 겪는 트러블슈팅

    여기서는 제가 실제로 많이 부딪혔던 문제 위주로 적어보겠습니다. 문서만 보면 단순해 보이는데, 현장에서는 꼭 꼬입니다.

    6-1. Pinning은 했는데 성능이 기대보다 안 나오는 경우

    가장 먼저 NUMA 배치를 의심해보세요. vCPU는 한 소켓 쪽에 몰렸는데 메모리는 다른 NUMA 노드에서 잡히면 메모리 접근이 꼬일 수 있습니다. 이럴 때는 인스턴스 XML과 호스트 NUMA 정보를 같이 확인해야 합니다.

    virsh dumpxml INSTANCE_DOMAIN | grep -i -E 'numa|vcpu|cputune|emulatorpin'
    numactl --hardware
    

    6-2. 동일한 벤치마크인데 결과 편차가 큰 경우

    이건 noisy neighbor 가능성이 큽니다. 특히 공유형 CPU 정책에서는 배치 타이밍에 따라 차이가 꽤 납니다. 저도 처음엔 테스트 툴 문제인 줄 알았는데, 같은 호스트에 다른 VM이 CPU burst를 치고 있었더라고요.

    6-3. 호스트는 여유 있는데 스케줄링이 실패하는 경우

    Placement(플레이스먼트, 자원 추적 및 배치 서비스) 관점에서 자원 클래스(resource class, 자원 분류)나 trait(특성)이 안 맞는 경우가 있습니다. 숫자상 여유와 스케줄링 가능 여부는 다를 수 있습니다. 그래서 단순히 top만 보는 식으로는 원인 파악이 안 됩니다.

    6-4. 에뮬레이터 스레드가 의외의 병목이 되는 경우

    이거 놓치기 쉽습니다. 전용 CPU만 신경 쓰다가 emulator thread가 같은 코어에 얹혀서 변동성이 생기기도 하거든요. 성능 민감 워크로드라면 이 부분도 꼭 확인해보세요.

    OpenStack Nova 성능 최적화 트러블슈팅과 벤치마크 편차 분석 이미지

    vCPU pinning, NUMA 노드, noisy neighbor 분석 지표를 함께 보는 트러블슈팅 예시 이미지입니다.

    7. 검증은 이렇게 합니다: 가상 머신 성능 확인 절차

    설정 바꾸고 느낌상 빨라진 것 같다고 끝내면 안 됩니다. 검증 절차를 남겨야 다음 변경 때도 비교가 되거든요. 저는 보통 아래 순서로 봅니다.

    1. 호스트 토폴로지 확인
    2. 인스턴스 배치 정책 확인
    3. 게스트 내부 CPU 인식 상태 확인
    4. 동일 조건으로 benchmark 반복 실행
    5. 평균값보다 편차와 최저 구간을 함께 비교
    # Example benchmark flow inside guest
    stress-ng --cpu 4 --timeout 60s --metrics-brief
    sysbench cpu --threads=4 run
    

    여기서 조심할 점은, 특정 툴의 점수 자체보다 반복 실행 시 일관성입니다. OpenStack Nova 성능 최적화가 잘 된 환경은 최고점만 높은 게 아니라, 여러 번 돌려도 편차가 상대적으로 줄어드는 경우가 많았습니다.

    검증 항목 좋은 신호 경계 신호
    CPU 사용률 분포 예상 코어에 집중 임의 분산, 잦은 변동
    Benchmark 반복성 결과 편차 작음 실행마다 차이 큼
    NUMA 정렬 CPU/메모리 지역성 유지 원격 메모리 접근 증가
    호스트 안정성 예약 자원 충분 호스트 자체가 바쁨

    드디어 됐다! 싶었던 순간도 사실 이런 표를 정리한 뒤에야 왔습니다. 그냥 체감이 아니라, 왜 결과가 좋아졌는지 설명이 되어야 다음 운영 변경에도 자신이 생기더라고요.

    OpenStack Nova 성능 최적화 전후 가상 머신 성능 비교 대시보드 이미지

    반복 벤치마크 결과의 편차 감소와 CPU 배치 안정성을 비교하는 결과 시각화 이미지입니다.

    8. 정리와 다음 단계: 무엇부터 손대면 좋을까

    정리해보면 OpenStack Nova 성능 최적화는 결국 세 가지입니다. 정책을 분리하고, 배치를 검증하고, 결과를 반복 측정하는 것이죠. Nova CPU 스케줄링은 단순 옵션 튜닝이 아니라, 워크로드 성격에 맞는 리소스 할당 전략을 설계하는 일에 가깝습니다.

    • 일반 워크로드는 공유 정책과 적절한 오버커밋으로 효율을 봅니다.
    • 민감한 워크로드는 전용 CPU, NUMA 정렬, 메모리 정책을 같이 봅니다.
    • 가상 머신 성능 평가는 평균 점수보다 재현성과 편차를 함께 봐야 합니다.
    • 벤치마크는 반드시 배치 정보와 같이 기록해야 의미가 있습니다.

    혹시 이런 경험 있으신가요? 분명 스펙은 같은데 어떤 VM만 유독 느린 상황이요. 그런 경우라면 애플리케이션을 의심하기 전에 CPU 정책과 배치 상태부터 보시는 걸 추천드립니다. 생각보다 거기서 답이 나오는 경우가 많거든요.

    다음 글에서는 Placement와 flavor extra spec을 조금 더 깊게 들어가서, 스케줄링 의도를 어떻게 코드처럼 관리할지 다뤄볼 예정입니다. 이전 글에서 다뤘던 가상화 호스트 기본 점검 내용과 함께 보시면 흐름이 더 잘 잡히실 겁니다.

    OpenStack Nova 성능 최적화 운영 체크리스트와 CPU 정책 요약 이미지

    공유 CPU와 전용 CPU 선택 기준, NUMA 체크포인트, 검증 절차를 요약한 인포그래픽 이미지입니다.

    자주 묻는 질문

    Q1. CPU overcommit을 무조건 낮추면 성능이 좋아지나요?

    항상 그렇진 않습니다. 집적도가 너무 낮아져 운영 효율이 떨어질 수 있고, 워크로드 특성상 공유 정책으로도 충분한 경우가 있습니다.

    Q2. Nova CPU 스케줄링만 조정하면 끝인가요?

    아닙니다. libvirt 설정, NUMA 구조, 메모리 정책, 게스트 OS 튜닝까지 함께 봐야 합니다.

    Q3. benchmark 결과가 매번 다르면 무엇부터 확인해야 하나요?

    테스트 시간대, noisy neighbor, 배치 호스트, NUMA 정렬, 에뮬레이터 스레드 정책 순으로 점검해보시면 됩니다.

  • [인프라] OpenStack Ironic으로 베어메탈 서버 자동 프로비저닝 실전 사례

    [인프라] OpenStack Ironic으로 베어메탈 서버 자동 프로비저닝 실전 사례

    [인프라] OpenStack Ironic으로 베어메탈 서버 자동 프로비저닝 실전 사례

    OpenStack Ironic 베어메탈 프로비저닝을 처음 제대로 붙잡았던 이유는 단순했습니다. 가상머신은 너무 익숙했는데, 정작 성능이 중요한 워크로드는 결국 물리 서버에 올려야 했거든요. 문제는 여기서부터였습니다. 서버를 한 대씩 BIOS 확인하고, PXE 부팅 잡고, 운영체제 이미지 밀어 넣고, 네트워크 맞추고, 다시 검증하는 과정을 반복하다 보니 사람이 할 일이 너무 많아지더라고요. 특히 서버가 3대, 5대, 10대로 늘어나면 그때부터는 실수도 같이 늘어납니다. 그래서 저는 OpenStack Ironic(아이로닉, 베어메탈 프로비저닝 서비스)을 도입해서 베어메탈 자동화 흐름을 만들었고, 실제로 운영 편의성이 얼마나 달라지는지 체감했습니다.

    혹시 이런 경험 있으신가요? 분명 같은 모델 서버인데도 한 대는 잘 올라오고, 한 대는 PXE에서 멈추고, 또 다른 한 대는 디스크 클리닝(cleaning) 단계에서 실패하는 상황이요. 저도 처음엔 이게 뭔가 싶었는데, 흐름을 한 번 제대로 잡고 나니까 서버 프로비저닝이 훨씬 예측 가능해졌습니다. 이번 글에서는 제가 직접 해보면서 정리한 OpenStack Ironic 베어메탈 프로비저닝 실전 사례를 기준으로, 개념부터 실제 등록과 배포, 그리고 삽질 포인트까지 차근차근 풀어보겠습니다.

    OpenStack Ironic, PXE 네트워크, 이미지 서비스, 관리 네트워크, 물리 서버 간의 전체 흐름을 한눈에 보여주는 아키텍처 예시입니다.

    1. 왜 베어메탈 자동화가 필요했는가

    제가 처음 자동화를 검토했던 환경은 대규모 클라우드까지는 아니고, 홈랩과 소규모 사내 테스트 랙(rack, 서버 장비 거치대)이 섞인 형태였습니다. 쿠버네티스 워커 노드, 스토리지 노드, 네트워크 기능 테스트 장비가 계속 늘어나는데, 설치 방법은 여전히 수동이었죠. 이러면 반복 작업이 많아질 뿐 아니라, 누가 언제 어떤 이미지로 설치했는지 추적도 어려워집니다.

    • 반복 작업 제거: 동일 OS 이미지와 네트워크 정책을 여러 서버에 일관되게 적용
    • 실수 감소: 수동 설치 중 IP, RAID, 부트 모드 입력 오류 감소
    • 재현성 확보: 장애 후 재배포(re-deploy) 시간이 짧아짐
    • 운영 표준화: 서버 모델이 달라도 등록 절차를 표준 흐름으로 묶기 쉬움

    여기서 중요한 포인트가 있습니다. 베어메탈 자동화는 단순히 설치를 편하게 하는 수준이 아니라, 물리 서버를 가상 리소스처럼 다루기 시작하는 첫 단계라는 점입니다. 실제로 써보니까 운영 관점이 바뀌더라고요. 서버를 장비가 아니라 풀(pool, 자원 집합)로 보게 됩니다.

    2. OpenStack Ironic 개념을 쉽게 풀어보면

    쉽게 말해 Ironic은 물리 서버를 API로 관리해 주는 서비스입니다. 가상머신을 Nova(노바, 컴퓨트 서비스)로 다루듯이, 베어메탈 서버는 Ironic으로 전원 제어, 부팅 제어, 이미지 배포, 상태 전환을 처리합니다.

    처음엔 용어가 좀 낯설 수 있습니다. 저도 처음엔 conductor가 뭐고 inspector가 뭐고 헷갈렸거든요. 실무에서는 아래 정도만 먼저 잡아도 흐름이 보입니다.

    구성 요소 역할 현장에서 이해한 방식
    Ironic API 베어메탈 요청 접수 사용자나 자동화 도구가 호출하는 입구
    Ironic Conductor 실제 작업 실행 전원 제어, 배포, 상태 변경을 수행하는 엔진
    PXE / iPXE 네트워크 부팅 로컬 디스크 없이 초기 부팅을 유도하는 통로
    IPA Ironic Python Agent 부팅 후 디스크 작업과 배포를 수행하는 에이전트
    BMC Baseboard Management Controller IPMI나 Redfish로 원격 전원/부트 제어
    Glance 이미지 저장소 배포할 운영체제 이미지를 보관하는 위치

    Ironic 베어메탈 프로비저닝 활용 사례로는 쿠버네티스 노드 자동 공급, Ceph(세프, 분산 스토리지) 스토리지 노드 배포, 테스트 장비 재설치 자동화가 대표적입니다. 특히 성능 오버헤드가 민감한 데이터 처리 워크로드에서는 가상화보다 베어메탈이 낫다고 판단하는 경우가 꽤 있죠.

    3. 실전 사례: OpenStack Ironic 베어메탈 프로비저닝 구성 방식

    이번 사례는 특정 벤더 기능에 기대지 않는, 비교적 범용적인 구성입니다. 관리 네트워크(management network)와 프로비저닝 네트워크(provisioning network)를 분리하고, BMC는 Redfish(레드피시, 표준 하드웨어 관리 API) 또는 IPMI 기반으로 접근했습니다. 디스크는 로컬 SSD를 사용했고, 운영체제 이미지는 일반적인 리눅스 클라우드 이미지 계열을 기준으로 배포했습니다.

    1. 서버 랙 장착 및 BMC IP 할당
    2. Ironic에 노드 등록
    3. 포트(MAC 주소) 연결
    4. 하드웨어 introspection(인트로스펙션, 자동 탐지) 또는 수동 속성 입력
    5. deploy image 연결
    6. manageable → available 상태 전환
    7. 베어메탈 서버 deploy 실행 및 부팅 검증

    이 흐름을 한 번 만들어 두면 신규 서버 반입 때 정말 편합니다. 예전에는 체크리스트를 사람이 읽으면서 따라갔는데, 이제는 등록 정보만 맞으면 나머지는 훨씬 기계적으로 흘러갑니다. 드디어 됐다 싶었던 순간이 여기였네요.

    4. OpenStack Ironic 베어메탈 프로비저닝 구현 단계

    4-1. 네트워크와 부트 방식 먼저 정리

    여기서 가장 많이 꼬입니다. Ironic 자체보다 PXE 네트워크가 더 큰 함정일 때가 많거든요. DHCP 범위, TFTP 또는 HTTP 부트 경로, UEFI/Legacy BIOS 모드가 서로 안 맞으면 배포가 시작도 안 됩니다. 저는 가능하면 UEFI 기준으로 통일하려고 했고, 스위치 포트 VLAN도 먼저 점검했습니다.

    openstack network list
    openstack subnet list
    openstack baremetal driver list
    openstack baremetal node list

    처음엔 단순히 노드만 등록하면 될 줄 알았는데, 실제로는 부팅 경로와 네트워크 경로가 먼저 안정화되어야 하더라고요. 특히 ToR(Top of Rack, 랙 상단 스위치) 쪽 포트 프로파일이 꼬여 있으면 증상이 굉장히 애매합니다.

    OpenStack Ironic 베어메탈 프로비저닝 PXE 부팅 흐름 이미지

    프로비저닝 VLAN, DHCP, HTTP/TFTP 부트, Ironic Conductor, 대상 서버 사이의 실제 데이터 흐름을 설명하는 이미지입니다.

    4-2. 노드 등록과 BMC 정보 입력

    다음은 물리 서버를 Ironic에 등록하는 단계입니다. 아래 예시는 개념을 보여주기 위한 형태이고, 환경에 맞게 driver와 driver-info 항목은 조정하시면 됩니다.

    openstack baremetal node create \
      --driver redfish \
      --name bm-node-01
    openstack baremetal node set bm-node-01 \
      --driver-info redfish_address=https://192.0.2.10/redfish/v1/Systems/1 \
      --driver-info redfish_username=admin \
      --driver-info redfish_password='REDACTED' \
      --property cpus=16 \
      --property memory_mb=65536 \
      --property local_gb=480 \
      --resource-class baremetal-general

    여기서 팁 하나요. 저는 초반에 서버 스펙을 전부 수동 입력했었는데, 장비가 늘어나면 이게 은근히 실수를 부릅니다. introspection을 쓸 수 있는 환경이라면 자동 탐지를 적극 활용하는 편이 낫습니다. 다만 자동 탐지 결과도 100% 맹신하면 안 되고, 디스크 수나 NIC 매핑은 꼭 눈으로 한 번 보셔야 합니다.

    4-3. 포트 연결과 배포 이미지 지정

    openstack baremetal port create aa:bb:cc:dd:ee:ff \
      --node bm-node-01
    openstack baremetal node set bm-node-01 \
      --instance-info image_source=<IMAGE_UUID> \
      --instance-info root_gb=50

    이미지 소스는 보통 Glance 이미지 UUID를 사용합니다. 저 같은 경우에는 운영체제 이미지 템플릿을 최소화해서 관리했는데, 이게 나중에 패치 기준점 맞추기가 편하더라고요. 이미지가 너무 많으면 자동화가 아니라 이미지 스파게티가 됩니다.

    4-4. 상태 전환과 배포 실행

    openstack baremetal node manage bm-node-01
    openstack baremetal node provide bm-node-01
    openstack baremetal node deploy bm-node-01

    Ironic은 상태(state)가 중요합니다. manageable, available, active 같은 상태 전환을 이해하지 못하면 왜 명령이 거부되는지 감이 안 옵니다. 저도 처음엔 deploy가 왜 안 되나 한참 봤는데, 앞단 상태가 안 맞았던 적이 꽤 많았습니다. 이 부분은 로그와 상태를 같이 보면서 익숙해지는 수밖에 없어요.

    5. OpenStack Ironic 베어메탈 프로비저닝: 운영 기준과 설정 예시

    실전에서는 단순 명령 몇 줄보다 운영 기준이 더 중요합니다. 어떤 노드를 어떤 용도로 쓸지, cleaning(클리닝, 디스크 초기화) 정책을 어디까지 강제할지, RAID 구성은 수동으로 둘지 자동으로 둘지 같은 정책이 먼저 있어야 자동화가 깔끔해집니다.

    nodes:
      - name: bm-node-01
        driver: redfish
        resource_class: baremetal-general
        boot_mode: uefi
        bmc:
          address: https://192.0.2.10/redfish/v1/Systems/1
          username: admin
        network:
          provisioning_mac: aa:bb:cc:dd:ee:ff
        deploy:
          image: ubuntu-base
          root_gb: 50

    저는 내부적으로 노드 인벤토리를 YAML 형태로 관리해 두고, 이후 등록 자동화 스크립트에서 읽어 쓰는 방식으로 정리했습니다. 이게 생각보다 큽니다. 사람이 콘솔에서 매번 입력하면 언젠가 오타가 나거든요.

    • 리소스 클래스(resource class)를 미리 정의해 워크로드 분류를 단순화
    • 부트 모드 통일로 장애 포인트 감소
    • 이미지 수 최소화로 운영 복잡도 감소
    • 인벤토리 코드화로 반복 등록 절차 표준화
    OpenStack Ironic 노드 등록과 상태 전환 운영 화면 이미지

    노드 이름, 드라이버, BMC 정보, 포트, 상태 전환 흐름이 한 번에 보이도록 구성한 운영 화면 예시입니다.

    6. ⚠️ 실제로 겪었던 문제와 해결 방법

    이 섹션이 아마 제일 현실적일 겁니다. 문서만 보면 다 잘 될 것 같은데, 실제 현장에서는 작은 불일치가 줄줄이 터집니다. 삽질 좀 했습니다 ㅎㅎ

    6-1. PXE는 되는데 베어메탈 배포가 중간에 멈추는 문제

    증상은 간단했습니다. 서버가 네트워크 부팅까지는 들어오는데, 에이전트가 올라온 뒤 이미지 배포 단계에서 멈추는 겁니다. 처음엔 이미지 문제인 줄 알았는데, 실제 원인은 프로비저닝 네트워크의 MTU와 업링크 설정 차이였습니다. 패킷 손실이 눈에 띄게 보이지 않아서 더 헷갈렸습니다.

    • 에이전트가 올라오는지 확인
    • Conductor 로그에서 타임아웃 여부 확인
    • 프로비저닝 VLAN 경로 MTU 점검
    • 이미지 다운로드 경로의 HTTP 접근성 확인

    6-2. BMC 연결은 되는데 전원 제어가 불안정한 문제

    이건 장비별 구현 차이 영향이 컸습니다. 같은 표준을 써도 Redfish 구현이 미묘하게 다르더라고요. 그래서 저는 가능하면 펌웨어 상태를 먼저 맞추고, 드라이버 타입을 혼용하지 않도록 정리했습니다. 환경에 따라 IPMI보다 Redfish가 더 안정적일 때도 있었고, 반대 경우도 있었습니다. 결국 중요한 건 표준 이름보다 내 장비에서 실제로 일관되게 동작하느냐였습니다.

    6-3. 디스크 선택이 꼬여 OS가 원하지 않는 장치에 설치되는 문제

    NVMe와 SATA SSD가 같이 있는 서버에서 이 문제가 나왔습니다. 에이전트가 잡는 장치 순서와 사람이 기대한 순서가 다를 수 있거든요. 그래서 배포 정책에서 디스크 선택 기준을 명확히 정하고, 가능하면 장치 특성 기반으로 선택하도록 운영 기준을 잡았습니다. 여기서 중요한 포인트! 베어메탈 자동화는 결국 하드웨어 다양성을 어떻게 통제하느냐의 싸움입니다.

    7. 검증과 결과: 서버 프로비저닝이 얼마나 달라졌나

    배포 후에는 단순히 active 상태만 보면 안 됩니다. 저는 최소한 아래 항목은 꼭 확인했습니다.

    1. Ironic 상태가 active로 전환되었는지 확인
    2. 운영체제가 정상 부팅되고 SSH 접근이 되는지 확인
    3. 의도한 NIC와 IP 정책이 적용되었는지 확인
    4. 디스크 레이아웃과 파일시스템이 기대값과 맞는지 확인
    5. 재배포 시 동일 절차가 반복 가능했는지 확인
    openstack baremetal node show bm-node-01
    openstack baremetal node validate bm-node-01

    실제로 써보니까 가장 큰 변화는 속도보다도 예측 가능성이었습니다. 예전에는 “이번에도 잘 되겠지”에 가까웠다면, 자동화 이후에는 “어디가 실패하면 무엇을 보면 된다”로 바뀌었습니다. 운영자는 이 차이를 굉장히 크게 느낍니다. 장애 대응 시간도 줄고, 신규 서버 투입 부담도 확실히 낮아졌습니다.

    OpenStack Ironic 베어메탈 프로비저닝 결과 검증 대시보드 이미지

    active 상태 전환, 배포 성공, 네트워크 연결, 운영체제 부팅 검증 결과를 시각적으로 요약한 이미지입니다.

    8. 정리: OpenStack Ironic 도입 전에 꼭 체크할 것

    OpenStack Ironic 베어메탈 프로비저닝은 분명 강력합니다. 하지만 설치 툴 하나 추가하는 수준으로 보면 실망할 수 있습니다. 이건 물리 서버 운영 체계를 재정리하는 일에 가깝거든요. 제가 직접 해보니 아래 네 가지가 성공 확률을 많이 좌우했습니다.

    • 네트워크 표준화: 프로비저닝 경로와 VLAN 정책을 먼저 안정화할 것
    • 하드웨어 편차 관리: 서버 모델, NIC, 디스크 구성을 가능한 한 단순화할 것
    • 상태 기반 운영: node state와 로그를 함께 보는 습관을 들일 것
    • 인벤토리 자동화: 등록 정보를 코드처럼 관리할 것
    도입 전 방식 Ironic 도입 후 방식
    서버별 수동 설치 API 기반 반복 배포
    작업자 숙련도 의존 절차 표준화
    문제 원인 추적 어려움 상태와 로그 기반 추적
    재설치 시간 편차 큼 재현성 높은 서버 프로비저닝

    혹시 지금 물리 서버를 계속 수동으로 설치하고 계시다면, 작은 랩 환경에서라도 먼저 시도해 보시는 걸 권합니다. 처음엔 헷갈립니다. 저도 그랬습니다. 근데 한 번 흐름을 이해하고 나면 이거 진짜 편하더라고요. 다음 글에서는 Ironic과 Inspector(인스펙터, 하드웨어 자동 탐지)를 엮어서 장비 등록을 더 줄이는 방향도 다뤄볼 예정입니다. 이전 글에서 다뤘던 PXE 네트워크 설계와 함께 보시면 훨씬 연결이 잘 되실 겁니다.

    OpenStack Ironic 도입 전후 비교 요약 인포그래픽

    수동 설치와 자동화된 베어메탈 프로비저닝의 차이, 그리고 도입 전 체크리스트를 한 장으로 정리한 요약 이미지입니다.

    9. 자주 묻는 질문

    Q1. Ironic은 꼭 OpenStack 전체를 다 써야 하나요?

    반드시 그렇지는 않습니다. 다만 실제 운영에서는 네트워크, 이미지, 인증 체계와의 연동이 중요해서 보통은 OpenStack 구성 요소와 함께 보는 편이 자연스럽습니다.

    Q2. 베어메탈 자동화가 작은 환경에도 의미가 있나요?

    의미 있습니다. 특히 재설치가 잦거나, 쿠버네티스 노드를 자주 교체하는 환경이라면 규모가 작아도 체감이 큽니다.

    Q3. Ironic 베어메탈 프로비저닝 활용 사례에서 가장 먼저 검증할 것은 뭔가요?

    저는 네트워크 부팅 경로와 BMC 안정성을 먼저 봅니다. 이 두 가지가 흔들리면 나머지 자동화가 전부 불안정해지거든요.

  • [OpenStack] 오픈스택 플레이버 최적화로 유휴 자원 줄이기

    [OpenStack] 오픈스택 플레이버 최적화로 유휴 자원 줄이기

    [OpenStack] 오픈스택 플레이버 최적화로 유휴 자원 줄이기

    프라이빗 클라우드 운영을 하다 보면 CPU는 남는데 메모리가 먼저 바닥나거나, 반대로 스토리지는 넉넉한데 작은 워크로드가 큰 VM 사양을 계속 잡아먹는 상황을 자주 보게 됩니다. 저도 홈랩과 업무 환경에서 이런 패턴을 여러 번 겪었고, 결국 문제의 중심에는 OpenStack 플레이버 설계가 있더라고요. 처음엔 인스턴스만 잘 뜨면 된다고 생각했는데, 실제로 써보니까 플레이버가 조금만 느슨해도 유휴 자원(idle resource)이 금방 쌓이고, 그게 곧 비용 압박으로 이어졌거든요.

    특히 프라이빗 클라우드 운영에서는 퍼블릭 클라우드처럼 청구서가 바로 날아오지 않아서 체감이 늦습니다. 근데 여기서 방심하면 안 됩니다. 서버 증설, 전력, 랙 공간, 백업, 운영 시간까지 다 합치면 결국 내부 비용이 꽤 커지거든요. 그래서 오늘은 OpenStack 플레이버를 어떻게 다듬어야 자원 최적화와 비용 절감을 동시에 가져갈 수 있는지, 제가 삽질했던 포인트까지 포함해서 정리해보겠습니다.

    OpenStack 플레이버가 프라이빗 클라우드 자원 배분에 미치는 구조를 보여주는 아키텍처 이미지

    플레이버 정의가 컴퓨트 노드 자원 사용률에 어떤 영향을 주는지 한눈에 보여주는 개요 이미지입니다.

    왜 OpenStack 플레이버 최적화가 중요한가

    쉽게 말해 플레이버는 VM의 기본 체급표입니다. vCPU, RAM, root disk 같은 자원 크기를 미리 정해두고, 사용자는 그중 하나를 골라 인스턴스를 만들게 되죠. 문제는 이 체급표가 현실과 안 맞을 때 생기더라고요.

    • 너무 큰 플레이버만 있으면 작은 서비스도 과하게 큰 자원을 점유합니다.
    • 너무 많은 플레이버가 있으면 운영 기준이 흐려지고, 사용자도 뭘 골라야 할지 헷갈립니다.
    • 이름 규칙이 제각각이면 자동화 스크립트와 정책 관리가 꼬이기 쉽습니다.
    • 워크로드 특성에 맞지 않는 비율로 설계하면 CPU overcommit(오버커밋)이나 메모리 낭비가 반복됩니다.

    저도 처음엔 부서 요청이 들어올 때마다 플레이버를 하나씩 추가했었습니다. 그때는 빨리 만들어주는 게 친절이라고 생각했는데요. 시간이 지나니까 m1-medium-v2-final 같은 이름이 생기고, 용도는 겹치고, 어떤 VM은 메모리만 남고 어떤 VM은 CPU만 묶여버리는 이상한 상태가 되더라고요. 그때부터 기준을 다시 세웠고, 드디어 좀 정리가 됐습니다.

    OpenStack 플레이버 개념, 쉽게 말해 이런 겁니다

    Flavor(플레이버, 가상머신 자원 템플릿)는 Nova(노바, OpenStack의 컴퓨트 서비스)에서 인스턴스 크기를 정의하는 단위입니다. 일반적으로 아래 항목을 포함합니다.

    • vCPU: 가상 CPU 개수
    • RAM: 메모리 크기(MB 단위)
    • Disk: 루트 디스크 크기(GB 단위)
    • Ephemeral Disk: 임시 디스크가 필요한 경우 사용하는 추가 디스크
    • Swap: 스왑 영역
    • extra_specs: 스케줄링, CPU 정책, NUMA 같은 추가 속성

    여기서 중요한 포인트! 플레이버는 단순히 숫자 몇 개를 묶어놓은 게 아닙니다. 실제로는 스케줄러(scheduler, 어느 컴퓨트 노드에 올릴지 결정하는 구성요소)와 운영 정책의 기준점 역할도 해요. 예를 들어 특정 플레이버에 dedicated CPU policy(전용 CPU 정책)나 huge pages(대용량 메모리 페이지) 같은 조건을 넣으면, 같은 4 vCPU / 8GB라도 완전히 다른 자원 소비 패턴이 됩니다.

    그래서 자원 최적화를 하려면 단순히 작은 플레이버를 늘리는 게 아니라, 어떤 워크로드를 어떤 비율로 태울지를 먼저 봐야 합니다. 사실 이걸 건너뛰면 플레이버만 바꾸고 결과는 그대로인 경우가 많더라고요.

    현재 상태부터 점검해보세요: 유휴 자원은 숫자로 봐야 합니다

    제가 직접 해보니 제일 먼저 해야 할 일은 플레이버를 새로 만드는 게 아니라, 지금 어떤 플레이버가 실제로 얼마나 쓰이는지 확인하는 일이었습니다. 감으로 보면 꼭 틀립니다. 특히 오래된 환경일수록 더 그렇거든요.

    1. 현재 등록된 플레이버 목록을 확인합니다.
    2. 인스턴스별로 어떤 플레이버가 얼마나 사용 중인지 집계합니다.
    3. 컴퓨트 노드별 vCPU, 메모리 사용률과 배치 불균형을 함께 봅니다.
    4. 실사용 대비 과대 할당된 표준 플레이버를 후보로 뽑습니다.
    openstack flavor list --long
    
    openstack server list --all-projects -f value -c ID -c Name -c Flavor
    
    openstack hypervisor list
    openstack hypervisor stats show

    CLI(Command Line Interface, 명령줄 인터페이스)로 보면 좀 투박하긴 한데, 오히려 현실이 잘 보여요. 예를 들어 플레이버는 12개인데 실제로 자주 쓰는 건 4개뿐인 경우가 꽤 많습니다. 반대로 이름은 비슷한데 메모리만 조금씩 다른 플레이버가 잔뜩 있는 환경도 있었고요.

    제가 운영하던 환경에서는 2 vCPU / 8GB 계열 플레이버가 유독 많았는데, 실제 앱은 메모리 3~4GB 수준만 쓰는 경우가 대부분이었습니다. 결국 메모리 단편화(fragmentation, 자원이 애매하게 쪼개져 남는 현상)가 심해졌고, 새 인스턴스를 띄울 때 특정 노드만 계속 부족하다는 알람이 뜨더라고요. CPU는 남는데 메모리 때문에 못 올리는 상황, 이거 꽤 자주 본답니다.

    OpenStack 플레이버 사용 편중과 자원 불균형을 보여주는 운영 대시보드 이미지

    실제 운영에서 자주 보게 되는 플레이버 사용 편중과 노드별 자원 불균형 예시를 보여주는 이미지입니다.

    표준 플레이버를 줄이고, 비율을 맞추는 게 비용 절감의 시작입니다

    여기서 중요한 건 플레이버 개수를 무조건 늘리는 게 아니라 표준화(standardization, 기준을 통일하는 작업)입니다. 저는 보통 워크로드를 세 가지로 나눠서 봅니다.

    • 범용형: 웹, API, 배치처럼 평균적인 CPU/메모리 비율
    • 메모리 집중형: 캐시, JVM, 분석 도구처럼 메모리 사용량이 큰 유형
    • 컴퓨트 집중형: 빌드, 인코딩, 일부 계산 작업처럼 CPU 사용량이 높은 유형

    이걸 바탕으로 플레이버를 단순하게 재구성하면 선택이 쉬워지고, 배치도 예측 가능해집니다. 아래는 많이 쓰는 정리 방식 예시입니다.

    구분 예시 이름 용도 설계 포인트
    범용형 gp.small / gp.medium 일반 웹, API, 업무 시스템 CPU와 메모리 비율을 균형 있게 유지
    메모리형 mem.small / mem.medium 캐시, 메모리 민감 서비스 같은 vCPU 대비 RAM 비율 확대
    컴퓨트형 cpu.small / cpu.medium 배치, 변환, CI 작업 메모리보다 CPU 효율 우선
    전용형 perf.large 성능 민감 워크로드 extra_specs로 정책 분리

    이름 규칙도 꽤 중요합니다. 저는 나중에 자동화할 걸 생각해서 접두사(prefix)를 꼭 넣어요. 예를 들면 gp, mem, cpu 같이요. 이렇게 해야 Terraform(테라폼, 인프라 코드 도구)이나 Ansible(앤서블, 자동화 도구)에서 분기하기 편하더라고요.

    참고로 플레이버를 설계할 때는 너무 세밀하게 자르는 것보다 20~30% 정도의 여유 구간을 가진 계단형 구성이 관리가 편합니다. 2GB, 3GB, 4GB, 5GB, 6GB 식으로 촘촘히 만들면 한동안은 좋아 보이는데, 운영자가 나중에 감당하기 힘들어진답니다.

    실전 구현: OpenStack 플레이버 재설계와 적용 순서

    이제 실제로 손을 대볼 차례입니다. 제가 보통 쓰는 절차는 아래 순서입니다. 한 번에 다 바꾸려고 하면 사고 나요. 저도 예전에 급하게 정리하다가 사용자한테 왜 목록이 바뀌었냐는 문의를 한꺼번에 받았거든요.

    1. 기존 플레이버 사용 현황을 수집합니다.
    2. 표준 플레이버 목록을 먼저 문서화합니다.
    3. 새 플레이버를 추가하되 기존 것은 바로 삭제하지 않습니다.
    4. 신규 배포부터 새 플레이버를 사용하게 유도합니다.
    5. 사용량이 떨어진 기존 플레이버를 단계적으로 비공개 또는 정리합니다.
    # 범용형 플레이버 생성 예시
    openstack flavor create gp.small \
      --vcpus 2 \
      --ram 4096 \
      --disk 20
    
    openstack flavor create gp.medium \
      --vcpus 4 \
      --ram 8192 \
      --disk 40
    
    # 메모리형 플레이버 생성 예시
    openstack flavor create mem.small \
      --vcpus 2 \
      --ram 8192 \
      --disk 20
    
    # extra_specs 설정 예시
    openstack flavor set perf.large \
      --property hw:cpu_policy=dedicated \
      --property hw:mem_page_size=large

    위 예시는 어디까지나 구조 예시입니다. 수치는 각 환경의 하이퍼바이저(hypervisor, 가상화 호스트) 구성과 워크로드 특성에 맞춰 잡으셔야 해요. 무작정 따라 넣는 건 추천하지 않습니다. 특히 전용 CPU 정책은 호스트 여유가 부족하면 오히려 배치 가능성이 떨어질 수 있거든요.

    실제로 써보니까 신규 플레이버를 만들고 바로 공지하는 것보다, Horizon(호라이즌, OpenStack 웹 대시보드) 또는 내부 포털에서 기본 선택지를 먼저 바꾸는 게 효과가 좋았습니다. 사용자는 기본값을 잘 따라가거든요. 이거 진짜 편하더라고요.

    표준 플레이버 생성과 정책 분리를 적용하는 과정을 시각적으로 보여주는 구성 이미지입니다.

    권장 운영 기준

    • 기존 플레이버는 즉시 삭제하지 말고 일정 기간 공존시키세요.
    • 프로젝트별 예외 요구는 별도 전용 플레이버로 격리하세요.
    • 자동 배포 템플릿에서 플레이버 이름을 하드코딩했다면 사전 점검이 필요합니다.
    • 비용 절감 효과는 VM 개수보다 호스트 증설 지연 효과에서 더 크게 나타날 수 있습니다.

    ⚠️ 제가 실제로 겪은 문제들: 트러블슈팅과 주의사항

    여기서부터가 진짜 운영 이야기예요. 문서에는 잘 안 나오는데, 실제론 이런 부분에서 많이 막힙니다.

    1. 플레이버만 줄였는데도 자원이 안 돌아오는 경우

    기존 인스턴스는 자동으로 새 플레이버를 쓰지 않아요. resize(리사이즈, 인스턴스 사양 변경)나 재배포가 필요합니다. 저도 처음엔 표준 플레이버 정리만 하면 바로 효과가 날 줄 알았는데, 기존 대형 인스턴스가 그대로 남아 있어서 체감 변화가 거의 없었습니다.

    # 인스턴스 리사이즈 예시
    openstack server resize --flavor gp.small <SERVER_ID>
    openstack server resize confirm <SERVER_ID>

    2. 메모리 단편화가 심해 배치가 꼬이는 경우

    플레이버 종류가 많으면 같은 총 메모리 용량이라도 애매하게 쪼개져 남아요. 이럴 때는 큰 플레이버를 무작정 유지하는 것보다, 중간 단계를 줄이고 범용형으로 수렴시키는 편이 낫더라고요.

    3. extra_specs를 너무 공격적으로 쓰는 경우

    특정 성능 요구 때문에 dedicated CPU나 huge pages를 광범위하게 쓰기 시작하면 스케줄링 제약이 커져요. 성능은 좋아질 수 있어도 전체 효율성은 오히려 떨어질 수 있습니다. 성능 민감 워크로드만 별도 클래스로 분리하는 게 안전했습니다.

    4. 이름만 바꾸고 정책은 안 바뀌는 경우

    이건 꽤 흔합니다. 이름을 optimized로 바꿔도 사용자가 여전히 가장 큰 플레이버를 고르면 의미가 없어요. 그래서 quota(쿼터, 프로젝트별 자원 한도), 기본 템플릿, 셀프서비스 포털 가이드까지 같이 손봐야 합니다.

    검증은 이렇게 보시면 됩니다: 자원 최적화가 됐는지 확인하는 법

    변경 후에는 감이 아니라 지표로 보셔야 해요. 저는 보통 아래 네 가지를 같이 봅니다.

    1. 플레이버별 인스턴스 분포가 표준 세트로 모였는지
    2. 컴퓨트 노드별 메모리/CPU 편차가 줄었는지
    3. 새 인스턴스 배치 실패가 감소했는지
    4. 호스트 증설 시점을 뒤로 미룰 수 있는지
    openstack hypervisor stats show
    openstack usage show --project <PROJECT_ID>
    openstack server list --all-projects --long

    제가 직접 해보니 가장 먼저 보이는 변화는 “애매하게 남는 자원”이 줄어드는 점이었어요. 예전에는 노드마다 2GB, 4GB, 6GB씩 찌꺼기처럼 남았는데 실제 배치엔 못 쓰는 경우가 많았거든요. 플레이버를 표준화하고 나니 배치 성공률이 안정되고, 신규 호스트 추가 논의를 한 템포 늦출 수 있었습니다. 프라이빗 클라우드 운영에서는 이 지점이 곧 비용 절감 효과로 이어집니다.

    🎉 특히 showback(쇼백, 내부 비용 가시화)이나 chargeback(차지백, 부서별 비용 배분) 체계가 있는 조직이라면 플레이버 표준화가 훨씬 중요합니다. 기준이 명확해야 부서별 사용 패턴도 설명하기 쉽고, 과도한 요청에 근거 있게 대응할 수 있거든요.

    OpenStack 플레이버 표준화 전후 자원 활용도 개선 결과를 보여주는 대시보드 이미지

    최적화 전후의 자원 활용도와 인스턴스 배치 효율 차이를 보여주는 결과 시각화 이미지입니다.

    자주 묻는 질문

    Q1. OpenStack 플레이버를 많이 만들수록 사용자 만족도가 높아지지 않나요?

    짧게 답하면, 꼭 그렇진 않습니다. 선택지가 너무 많으면 오히려 잘못 고를 확률이 높아져요. 표준 플레이버는 적게, 예외는 분리해서 운영하는 쪽이 장기적으로 효율적이었습니다.

    Q2. 비용 절감 효과를 어떻게 설명하면 좋을까요?

    직접적인 청구 금액보다 호스트 증설 지연, 배치 실패 감소, 유휴 자원 감소 관점으로 설명하는 게 현실적이에요. 프라이빗 클라우드 운영에서는 이게 훨씬 설득력이 있습니다.

    Q3. 기존 인스턴스는 언제 옮기는 게 좋을까요?

    서비스 영향이 적은 점검 창을 잡아서 순차적으로 resize하거나, 재배포 주기에 맞춰 천천히 전환하는 게 안전해요. 한 번에 몰아붙이면 운영팀만 고생합니다. 저도 그렇게 삽질 좀 했습니다.

    정리: 비용 절감은 작은 플레이버가 아니라 좋은 기준에서 시작됩니다

    OpenStack 플레이버 최적화의 핵심은 단순히 VM 사양을 낮추는 게 아니에요. 워크로드를 분류하고, 표준 타입을 정하고, 운영 정책과 연결하는 것이죠. 이 흐름이 잡히면 자원 최적화, 효율성 개선, 비용 절감이 같이 따라옵니다. 반대로 기준 없이 요청마다 플레이버를 추가하면 언젠가 운영 복잡도가 비용으로 돌아와요.

    혹시 지금 환경에서 플레이버 이름이 제각각이거나, 어떤 걸 없애도 되는지 감이 안 오신다면 먼저 사용 현황부터 뽑아보세요. 거기서 답이 보여요. 다음 글에서는 quota 설계와 프로젝트별 자원 정책을 어떻게 묶어야 실제 프라이빗 클라우드 운영이 편해지는지 다뤄볼 예정입니다. 이전 글에서 다룬 하이퍼바이저 자원 모니터링 글과 함께 보셔도 흐름이 더 잘 잡히실 거예요.

    OpenStack 플레이버 설계 원칙과 비용 절감 포인트를 요약한 인포그래픽

    표준화, 운영 정책, 비용 절감 포인트를 한 장으로 정리한 요약 이미지입니다.

    ✅ 오늘 내용만 실무에 적용해도, 플레이버 목록 정리와 기본값 개선만으로 꽤 큰 차이를 느끼실 가능성이 높습니다. 저도 처음엔 이게 뭔가 싶었는데, 막상 정리하고 나니 운영이 훨씬 덜 피곤해졌거든요.

  • [OpenStack] OpenStack Cinder 볼륨 생성 실패? 흔한 원인과 해결책

    [OpenStack] OpenStack Cinder 볼륨 생성 실패? 흔한 원인과 해결책

    OpenStack Cinder 볼륨 생성 실패? 흔한 원인과 해결책

    OpenStack Cinder 오류 때문에 볼륨이 안 만들어지는 상황, 운영하다 보면 한 번쯤은 꼭 겪게 됩니다. 인스턴스는 잘 뜨는데 스토리지 쪽에서 갑자기 발목을 잡으면 진짜 답답하거든요. 저도 홈랩과 실서비스 비슷한 테스트 환경에서 Cinder 볼륨 생성이 계속 실패해서 한참 삽질했었습니다. 처음엔 Nova(컴퓨트 서비스) 문제인가 싶었는데, 실제로 파고 들어가 보니 메시지는 비슷해도 원인은 꽤 다양하더라고요.

    이번 글에서는 OpenStack Cinder 오류가 났을 때 어디부터 봐야 하는지, 어떤 로그를 먼저 열어야 하는지, 그리고 OpenStack 스토리지 문제를 어떻게 단계적으로 좁혀 가는지 제 경험 기준으로 정리해보겠습니다. 특히 막연하게 재시도만 하는 대신, Cinder 디버깅 관점에서 원인을 빠르게 찾는 흐름에 집중해볼게요.

    OpenStack 환경에서 Cinder, Nova, 백엔드 스토리지가 어떻게 연결되는지 보여주는 개요 이미지입니다.

    1. OpenStack Cinder 오류는 왜 그렇게 자주 터질까요?

    쉽게 말해 Cinder(블록 스토리지 서비스)는 단순히 디스크 파일 하나 만드는 역할이 아닙니다. API 요청을 받고, 스케줄러가 적절한 백엔드로 보내고, 실제 스토리지 드라이버가 LVM(Logical Volume Manager)이나 Ceph(분산 스토리지) 같은 백엔드에 볼륨을 생성하는 구조거든요. 중간 단계가 많다 보니 어디 한 군데만 어긋나도 사용자 입장에서는 그냥 볼륨 생성 실패로 보입니다.

    제가 직접 해보니 특히 아래 네 군데에서 많이 막혔습니다.

    • 서비스 상태 이상: cinder-api, cinder-scheduler, cinder-volume 중 하나가 비정상
    • 백엔드 설정 오류: volume_backend_name, target_helper, 드라이버 옵션 불일치
    • 권한/연결 문제: iSCSI, RBD, LVM 명령 실행 실패
    • 용량 부족: 실제 디스크 또는 풀(pool) 여유 공간 부족

    여기서 중요한 포인트! 에러 메시지 한 줄만 보고 판단하면 거의 항상 돌아갑니다. 요청 경로를 따라가면서 Cinder 디버깅을 체계적으로 진행해야 합니다.

    2. Cinder 볼륨 생성 흐름을 먼저 이해해보겠습니다

    저도 처음엔 헷갈렸는데, 구조를 이해하면 로그 보는 순서가 훨씬 쉬워집니다.

    1. 사용자가 Horizon(대시보드) 또는 CLI로 볼륨 생성 요청
    2. cinder-api가 요청을 받음
    3. cinder-scheduler가 어떤 백엔드에 생성할지 결정
    4. cinder-volume이 실제 스토리지 드라이버 호출
    5. LVM, Ceph RBD, NFS 같은 백엔드에서 실제 볼륨 생성

    즉, 볼륨이 안 만들어지면 API, 스케줄링, 백엔드 실행까지 모두 후보입니다. 그래서 저는 늘 서비스 상태 확인 → 볼륨 상태 확인 → 로그 확인 → 백엔드 직접 점검 순서로 갑니다. 이 흐름이 제일 덜 꼬였습니다.

    3. 기본 점검: 가장 먼저 확인할 사항

    솔직히 여기서 끝나는 경우도 꽤 많습니다. 너무 복잡하게 보기 전에 기본 체크부터 해보세요.

    3-1. Cinder 서비스 상태 확인

    openstack volume service list
    systemctl status openstack-cinder-api
    systemctl status openstack-cinder-scheduler
    systemctl status openstack-cinder-volume

    서비스 목록에서 enabled/up 상태인지 먼저 봅니다. 특히 cinder-volume이 down이면 백엔드까지 요청이 안 내려갑니다. 실제로 써보니까 API는 살아 있는데 volume 서비스만 죽어 있는 케이스가 은근 많더라고요.

    3-2. 실패한 볼륨 상태 확인

    openstack volume list
    openstack volume show <VOLUME_ID>

    error, error_deleting, creating에서 멈췄는지 봐야 합니다. creating 상태가 오래 유지되면 백엔드 작업이 걸렸거나 스케줄링 이후 후속 처리가 멈췄을 가능성이 있습니다.

    3-3. quota(쿼터, 자원 할당량) 확인

    openstack quota show <PROJECT_ID>

    의외로 단순한 프로젝트 quota 초과 때문에 OpenStack Cinder 오류처럼 보일 때도 있습니다. 특히 테스트 환경에서는 이것 때문에 시간을 꽤 쓰게 되네요.

    OpenStack Cinder 오류 점검을 위한 서비스 상태와 볼륨 확인 이미지

    초기 점검 단계에서 서비스 상태와 볼륨 상태를 어떻게 확인하는지 보여주는 이미지입니다.

    4. Cinder 디버깅의 핵심: 로그를 요청 흐름대로 읽기

    이제부터는 본격적인 문제 해결입니다. 여기서는 로그를 한 군데만 보는 게 아니라 요청 흐름대로 나눠서 보는 게 Cinder 디버깅의 핵심입니다.

    4-1. API와 스케줄러 로그 확인

    journalctl -u openstack-cinder-api -n 200 --no-pager
    journalctl -u openstack-cinder-scheduler -n 200 --no-pager

    여기서 보는 포인트는 두 가지입니다. 첫째, 요청이 정상적으로 들어왔는지. 둘째, 스케줄러가 백엔드를 찾지 못했는지입니다. 만약 No valid backend 같은 메시지가 보이면 백엔드 이름 불일치나 capacity 정보 수집 실패를 의심해볼 수 있습니다.

    4-2. cinder-volume 로그로 근본 원인 찾기

    journalctl -u openstack-cinder-volume -n 300 --no-pager

    볼륨 생성 실패 원인은 대부분 여기서 실마리가 나옵니다. 드라이버 예외, 인증 실패, 디바이스 생성 실패, 명령 실행 오류가 다 이쪽에 남습니다. 처음엔 이게 뭔가 싶었는데, 에러 한 줄보다 바로 위아래 문맥이 더 중요하더라고요.

    4-3. 백엔드 직접 확인하기

    LVM 백엔드라면 볼륨 그룹이 실제로 보이는지 확인합니다.

    vgs
    lvs
    pvs

    Ceph RBD 백엔드라면 풀 접근이 되는지, 인증이 맞는지 확인합니다.

    ceph -s
    rbd ls <POOL_NAME>

    여기서 막히면 Cinder 문제가 아니라 사실상 백엔드 스토리지 문제인 경우가 많습니다. 이럴 때는 접근 방향을 바꿔야 합니다.

    5. 흔한 원인과 해결책: 빠르게 참고할 표

    제가 자주 봤던 패턴을 표로 정리해보겠습니다. 운영 중이면 이 표만 보고도 대략 감이 올 때가 있습니다.

    증상 가능한 원인 확인 포인트 해결 방향
    볼륨이 계속 creating 상태 백엔드 응답 지연 또는 작업 멈춤 cinder-volume 로그, 백엔드 상태 백엔드 연결 확인, stuck 작업 정리
    즉시 error 상태로 전환 드라이버 설정 오류 cinder.conf, volume_backend_name 설정값 정합성 수정 후 서비스 재시작
    No valid backend 스케줄러가 사용 가능한 백엔드 없음 scheduler 로그, capacity 보고값 backend 등록 상태와 용량 정보 점검
    권한 관련 오류 스토리지 인증 또는 OS 권한 부족 Ceph keyring, LVM 실행 권한 자격 증명과 실행 계정 권한 수정
    간헐적 실패 네트워크 또는 메시지 큐 지연 MQ, DB, 관리 네트워크 지연 인프라 레이어 상태 함께 점검

    5-1. 설정 파일에서 자주 실수하는 부분

    [DEFAULT]
    enabled_backends = lvm
    
    [lvm]
    volume_driver = cinder.volume.drivers.lvm.LVMVolumeDriver
    volume_group = cinder-volumes
    volume_backend_name = LVM
    target_helper = tgtadm

    여기서 enabled_backends와 섹션 이름, volume_backend_name이 꼬이면 스케줄러가 백엔드를 인식하지 못합니다. 저는 예전에 섹션 이름은 lvm인데 다른 쪽 설정에서 백엔드 이름을 다르게 참조해둬서 몇 시간을 날렸습니다. 정말 삽질했네요.

    수정 후에는 보통 관련 서비스를 다시 올려줘야 합니다.

    systemctl restart openstack-cinder-volume
    systemctl restart openstack-cinder-scheduler
    Cinder 볼륨 생성 설정과 백엔드 매핑을 설명하는 이미지

    enabled_backends, 섹션 이름, volume_backend_name 관계를 이해하기 쉽게 보여주는 구성 이미지입니다.

    6. ⚠️ OpenStack 스토리지 운영에서 자주 놓치는 부분

    여기부터는 경험상 체감 비중이 높았던 항목입니다.

    6-1. 디스크 용량은 남았는데도 실패하는 경우

    겉으로는 스토리지 여유가 있어 보여도, thin provisioning(씬 프로비저닝) 설정이나 reserved space(예약 공간) 때문에 실제 할당 가능 용량이 부족할 수 있습니다. 특히 LVM thin pool을 쓰면 숫자만 보고 안심했다가 나중에 뒤통수 맞기 쉽습니다.

    6-2. 메시지 큐와 데이터베이스 지연

    Cinder만 보는 게 아니라 RabbitMQ(메시지 브로커)나 MariaDB/MySQL 같은 공통 인프라 레이어도 함께 봐야 합니다. 요청은 들어갔는데 상태 갱신이 늦거나 작업 분배가 밀리면 사용자 눈에는 그냥 실패처럼 보이거든요.

    6-3. 멀티백엔드 환경의 우선순위 문제

    백엔드가 여러 개면 특정 volume type(볼륨 타입)이 어느 백엔드로 가는지 꼭 확인해야 합니다. volume type과 extra specs(추가 속성)가 맞지 않으면 엉뚱한 백엔드로 가거나 스케줄링에 실패할 수 있습니다.

    openstack volume type list
    openstack volume type show <VOLUME_TYPE>

    혹시 이런 경험 있으신가요? 분명 Ceph로 보내야 하는데 기본 타입 때문에 LVM으로 가고 있던 상황이요. 이거 생각보다 자주 나옵니다.

    7. 해결책 검증하기: 실제로 동작하는지 확인

    원인을 수정했다면 반드시 재현 테스트를 해봐야 합니다. 저는 아래 순서대로 확인합니다.

    1. 테스트용 소형 볼륨 생성
    2. 상태가 available로 바뀌는지 확인
    3. 인스턴스에 attach(연결) 테스트
    4. OS 내부에서 블록 디바이스 인식 확인
    openstack volume create --size 1 test-volume
    openstack volume list
    openstack server add volume <SERVER_ID> <VOLUME_ID>

    인스턴스 내부에서는 보통 아래처럼 확인합니다.

    lsblk
    sudo fdisk -l

    여기까지 정상이라면 일단 급한 불은 껐다고 봐도 됩니다. 드디어 됐다! 하는 순간이 오긴 오더라고요.

    OpenStack Cinder 오류 해결 후 볼륨 생성과 attach 검증 이미지

    문제 해결 후 볼륨 상태가 정상으로 바뀌고 인스턴스에 연결된 결과를 보여주는 검증 이미지입니다.

    8. 자주 묻는 질문 정리

    Q1. Cinder 디버깅은 로그를 어디부터 봐야 하나요?

    openstack volume show로 상태를 보고, 그다음 cinder-scheduler, cinder-volume 순으로 보시면 됩니다. 백엔드 생성 실패는 보통 cinder-volume에 단서가 많습니다.

    Q2. Horizon에서는 실패라고만 나오는데요?

    그럴 때는 CLI가 훨씬 낫습니다. Horizon은 요약 메시지만 보여주는 경우가 많아서요. 실제 현장에서는 CLI와 journalctl 조합이 훨씬 빠릅니다.

    Q3. OpenStack Cinder 오류가 간헐적으로만 발생합니다

    이 경우는 설정 오류보다 인프라 지연, 네트워크 흔들림, 메시지 큐 병목 같은 문제일 가능성이 높습니다. 그래서 애플리케이션 로그만 보지 말고 아래도 함께 봐야 합니다.

    • 관리 네트워크 지연
    • 메시지 큐 적체
    • DB 응답 시간
    • 백엔드 스토리지 클러스터 상태

    9. 마무리: Cinder 볼륨 생성 실패는 체계적으로 접근하세요

    Cinder 볼륨 생성 실패는 겉보기엔 단순하지만, 실제로는 API, 스케줄러, 볼륨 서비스, 백엔드 스토리지까지 다 연결된 문제입니다. 그래서 OpenStack Cinder 오류를 빨리 잡으려면 감으로 접근하면 안 되고, 요청 흐름 기준으로 차근차근 좁혀 가야 합니다. Cinder 디버깅의 원칙만 지켜도 복구 시간이 꽤 줄었습니다.

    정리하면 이렇습니다.

    • 서비스 상태부터 확인합니다
    • 볼륨 상태와 로그를 함께 봅니다
    • 백엔드 스토리지를 직접 검증합니다
    • quota, volume type, 멀티백엔드 매핑도 놓치지 않습니다

    다음 글에서는 Cinder와 Ceph RBD 조합에서 자주 만나는 장애 포인트를 따로 정리해볼 예정입니다. OpenStack Cinder 오류 해결에 필요한 Nova attach 흐름도 함께 보시면 전체 그림 이해에 도움이 됩니다.

    OpenStack Cinder 오류 점검 순서를 정리한 요약 인포그래픽

    서비스, 로그, 백엔드, 검증 순서로 이어지는 Cinder 트러블슈팅 체크리스트 요약 이미지입니다.

  • [인프라] OpenStack TCO 분석: VMware 대안, 실제 비용은 얼마나 줄어드나?

    [인프라] OpenStack TCO 분석: VMware 대안, 실제 비용은 얼마나 줄어드나?

    [인프라] OpenStack TCO 분석: VMware 대안, 실제 비용은 얼마나 줄어드나?

    VMware 대안으로 OpenStack을 검토하시는 분들이 제일 먼저 묻는 건 결국 하나입니다. "그래서 돈이 얼마나 줄어드는데?" 저도 그랬습니다. 처음엔 라이선스만 빼면 무조건 싸질 줄 알았거든요. 그런데 실제로 OpenStack VMware TCO를 따져보면 그렇게 단순하지 않더라고요. 라이선스(License, 사용권) 비용은 분명 큰 축이지만, 운영 인력, 자동화 수준, 장애 대응 체계, 하드웨어 표준화 같은 요소가 함께 들어와야 진짜 총소유비용(TCO, Total Cost of Ownership)이 보입니다.

    특히 요즘은 프라이빗 클라우드 비용을 다시 계산하는 팀이 많습니다. 기존 VMware 환경을 유지할지, VMware 대안으로 OpenStack 같은 오픈소스 기반 프라이빗 클라우드로 갈지, 아니면 일부만 전환할지 고민이 커졌거든요. 제가 홈랩(Home Lab, 개인 실험실)과 실무 환경에서 직접 검토해보니, OpenStack은 라이선스 절감만 보고 들어가면 삽질하기 쉽고, 반대로 운영 모델까지 같이 설계하면 꽤 설득력 있는 선택지가 됩니다.

    여기서 중요한 포인트! 이 글은 "무조건 OpenStack이 싸다" 같은 결론을 밀어붙이는 글이 아닙니다. 실제 비용 절감 효과가 어느 구간에서 생기는지, 그리고 어떤 팀은 오히려 더 비싸질 수 있는지, 경험 기반으로 정리해보겠습니다.

    OpenStack VMware TCO 비교 아키텍처 개요 이미지

    OpenStack과 VMware 기반 프라이빗 클라우드의 비용 구조와 운영 요소를 한눈에 보여주는 개요 이미지입니다.

    1. 왜 OpenStack VMware TCO 분석이 중요한가

    쉽게 말해 TCO는 "도입 가격"이 아니라 "몇 년 동안 실제로 나가는 총비용"입니다. 서버 몇 대 샀는지로 끝나는 게 아니거든요.

    • CapEx(Capital Expenditure, 자본 지출): 서버, 스토리지, 네트워크 장비처럼 처음 들어가는 비용
    • OpEx(Operational Expenditure, 운영 지출): 유지보수, 인력, 전력, 상면, 교육, 장애 대응 비용
    • 전환 비용(Migration Cost, 마이그레이션 비용): 기존 VMware 워크로드를 옮기기 위해 드는 검증과 운영 변경 비용

    저도 처음엔 라이선스 항목만 엑셀에서 지우고 "와, 많이 줄겠네" 했는데요. 막상 계산해보니 OpenStack은 운영 자동화가 덜 되어 있으면 사람 시간이 꽤 필요하더라고요. 반대로 환경이 커질수록, 그리고 내부에 Linux/KVM 역량이 쌓일수록 프라이빗 클라우드 비용 구조가 달라집니다. 이 지점이 핵심입니다.

    2. OpenStack을 VMware 대안으로 볼 때 개념부터 정리

    OpenStack은 가상머신, 네트워크, 스토리지 자원을 API 기반으로 관리하는 프라이빗 클라우드 플랫폼입니다. VMware처럼 완성도 높은 상용 스택 하나를 산다기보다, 여러 컴포넌트를 조합해 클라우드 운영 체계를 만든다고 보시면 이해가 쉽습니다.

    OpenStack 핵심 구성요소

    • Nova(노바, 컴퓨트 관리): 가상머신 생성과 스케줄링
    • Neutron(뉴트론, 네트워크 관리): 가상 네트워크, 라우팅, 보안 그룹
    • Cinder(신더, 블록 스토리지): VM용 디스크 볼륨
    • Glance(글랜스, 이미지 서비스): VM 이미지 저장소
    • Keystone(키스톤, 인증/권한): 사용자와 프로젝트 접근 제어

    반면 VMware는 vSphere, vCenter 같은 상용 관리 체계가 이미 다듬어져 있어서 초기 진입 장벽이 낮은 편입니다. 그래서 OpenStack VMware TCO 비교는 단순히 기능 비교가 아니라 운영 모델 비교로 봐야 합니다. 저도 처음엔 이게 뭔가 싶었는데, 실제로 써보니까 기술 선택보다 운영 철학 차이가 더 크더라고요.

    3. 프라이빗 클라우드 비용, 어디서 갈리나

    비용을 나눠보면 판단이 훨씬 쉬워집니다. 아래 표처럼 보시면 됩니다.

    비용 항목 VMware OpenStack 체크 포인트
    라이선스 상용 라이선스 및 서브스크립션 부담 가능 오픈소스 자체는 라이선스 부담이 낮음 상용 지원 계약 포함 여부 확인
    초기 구축 상대적으로 표준화된 구축 절차 설계와 통합 난이도 높을 수 있음 내부 인력 숙련도 중요
    운영 자동화 관리도구 성숙도 높음 자동화 수준에 따라 편차 큼 Ansible, Terraform 연계 여부
    인력 비용 상용 운영 경험자 수급 비교적 수월 Linux/KVM/OpenStack 경험자 필요 교육 비용과 채용 난이도 반영
    확장성 기능 확장 시 비용 증가 가능 대규모 표준화 환경에 유리할 수 있음 노드 증가 시 운영 효율 점검
    벤더 종속 상대적으로 높을 수 있음 구성 자유도 높음 장기 전략과 맞는지 확인

    여기서 제가 꼭 말씀드리는 게 있습니다. OpenStack은 "라이선스 절감"보다 "운영 체계 내재화"에서 이득이 나는 경우가 많습니다. 반대로 작은 조직에서 운영 전담자 없이 도입하면, 장애 한 번에 절감한 비용이 바로 날아가기도 합니다. 삽질 좀 했습니다 ㅎㅎ

    4. 실제 TCO 분석은 이렇게 해야 덜 틀립니다

    제가 실무에서 비용 비교할 때는 감으로 안 갑니다. 최소 3년 기준으로 항목을 나눠서 봐야 합니다. 1년만 보면 전환 비용이 과하게 커 보이고, 너무 길게 보면 변수 통제가 안 되거든요.

    1. 현행 VMware 비용 기준선(Baseline)을 만든다.
    2. OpenStack 전환 시나리오를 최소 2개 만든다. 완전 전환, 일부 워크로드 전환.
    3. 공통 비용과 차등 비용을 분리한다.
    4. 운영 인건비를 반드시 넣는다.
    5. 장애 리스크와 학습 곡선을 숫자 대신 등급으로라도 반영한다.

    제가 주로 쓰는 TCO 분류 템플릿

    # 예시: 비용 분류 디렉터리 만들기
    mkdir -p tco/{baseline,openstack,shared}
    
    cat > tco/baseline/vmware_cost_items.csv <<'EOF'
    category,item,period,notes
    license,hypervisor_subscription,annual,vmware related recurring cost
    support,vendor_support,annual,commercial support contract
    hardware,compute_nodes,3year,existing or refresh cycle
    operations,admin_labor,annual,platform operation labor
    facility,power_and_rack,annual,datacenter operating expense
    migration,upgrade_project,one-time,major version or redesign effort
    EOF

    이런 식으로 분류를 먼저 해두면 회의할 때 덜 흔들립니다. 숫자부터 넣으면 부서마다 기준이 달라져서 금방 싸움 나거든요.

    프라이빗 클라우드 비용 분석을 위한 OpenStack VMware TCO 워크시트 이미지

    라이선스, 인력, 하드웨어, 지원 비용을 나눠서 비교하는 TCO 분석 워크시트 예시입니다.

    OpenStack 자원 현황 수집 예시

    OpenStack 쪽도 막연하게 "오픈소스니까 싸다"로 접근하면 안 됩니다. 실제 필요한 노드 수와 운영 범위를 봐야 합니다.

    # OpenStack 클라우드 자원 현황 확인 예시
    openstack hypervisor list
    openstack compute service list
    openstack network agent list
    openstack volume service list
    openstack server list --all-projects
    openstack flavor list

    위 명령은 특별한 마법이 있는 게 아니라, 현재 몇 대를 운영하고 있고 어떤 서비스가 붙어 있는지를 구조적으로 보는 출발점입니다. VMware 대안 검토에서 중요한 건 기능 체크리스트보다 실제 운영 대상의 크기거든요.

    간단한 비교용 계산 스크립트 예시

    from dataclasses import dataclass
    
    @dataclass
    class TCO:
        license_cost: float = 0.0
        support_cost: float = 0.0
        hardware_cost: float = 0.0
        labor_cost: float = 0.0
        facility_cost: float = 0.0
        migration_cost: float = 0.0
    
        def total(self) -> float:
            return (
                self.license_cost
                + self.support_cost
                + self.hardware_cost
                + self.labor_cost
                + self.facility_cost
                + self.migration_cost
            )
    
    vmware = TCO(
        license_cost=0,
        support_cost=0,
        hardware_cost=0,
        labor_cost=0,
        facility_cost=0,
        migration_cost=0,
    )
    
    openstack = TCO(
        license_cost=0,
        support_cost=0,
        hardware_cost=0,
        labor_cost=0,
        facility_cost=0,
        migration_cost=0,
    )
    
    print({
        "vmware_tco": vmware.total(),
        "openstack_tco": openstack.total(),
        "difference": vmware.total() - openstack.total(),
    })

    일부러 숫자는 비워뒀습니다. 확실하지 않은 수치를 넣어서 그럴듯하게 만드는 게 제일 위험하거든요. 각 조직의 계약 구조와 인건비 기준이 다르니, 여러분 환경 숫자를 직접 넣어야 합니다.

    5. OpenStack 도입 시 실제로 비용 절감이 나는 구간

    제가 직접 해보니, 비용 절감은 보통 아래 조건에서 더 잘 보였습니다.

    • 가상화 규모가 크고 표준화가 잘 된 환경
    • Linux/KVM 운영 경험이 이미 있는 팀
    • 자동화 도구를 적극적으로 쓰는 조직
    • 벤더 종속을 줄이고 내부 플랫폼 역량을 쌓으려는 경우

    반대로 다음 조건에서는 조심해야 합니다.

    • 소규모 환경인데 운영팀이 매우 얇은 경우
    • 장애 대응을 거의 벤더에 의존해온 경우
    • 조직 내 네트워크와 스토리지 표준이 정리되지 않은 경우

    이건 진짜 많이 놓치는데요. 프라이빗 클라우드 비용은 기술보다 조직 성숙도에 더 민감합니다. OpenStack은 자유도가 높아서 잘 쓰면 좋습니다. 근데 정리 안 된 환경에서 도입하면 복잡성이 그대로 비용이 됩니다.

    6. ⚠️ 제가 겪었던 트러블슈팅과 함정

    여기서는 현실 얘기 좀 해보겠습니다. TCO 문서에는 잘 안 적히는데, 실제론 이런 게 큽니다.

    1) 운영 인건비를 너무 낮게 잡는 실수

    처음엔 오픈소스니까 라이선스 절감폭만 크게 보입니다. 근데 초반엔 Runbook(런북, 운영 절차 문서) 정리, 모니터링, 백업, 네트워크 연동, 권한 체계 정비에 시간이 꽤 들어갑니다. 초기 6~12개월 운영 안정화 비용을 별도 항목으로 잡는 게 좋습니다.

    2) 마이그레이션 난이도를 균일하게 보는 실수

    모든 VM이 똑같이 잘 옮겨지지 않습니다. 에이전트 의존성이 있거나, 특정 네트워크 정책에 묶인 워크로드는 손이 더 갑니다. 그래서 저는 항상 워크로드를 세 그룹으로 나눕니다.

    1. 쉽게 이전 가능
    2. 테스트 후 이전 가능
    3. 유지 또는 재설계 필요

    3) 상용 지원 계약을 0원처럼 보는 실수

    OpenStack도 엔터프라이즈 환경이면 지원 체계가 필요합니다. 내부에서 다 감당 가능한 팀이 아니라면, 결국 지원 계약이나 파트너 비용이 들어갑니다. 이걸 빼면 비교가 왜곡됩니다.

    4) 네트워크 설계를 나중으로 미루는 실수

    Neutron(뉴트론, 네트워크 관리) 설계를 얕게 보면 나중에 VLAN, 라우팅, 보안 그룹, 외부망 연결에서 많이 막힙니다. 저도 홈랩에서 처음엔 컴퓨트만 올리면 끝인 줄 알았는데, 실제로는 네트워크가 시간을 제일 많이 먹더라고요.

    OpenStack 네트워크와 컴퓨트 구성으로 보는 VMware 대안 구조 이미지

    OpenStack 환경에서 네트워크, 컴퓨트, 스토리지 구성이 어떻게 연결되는지 보여주는 다이어그램입니다.

    7. 검증과 결과 해석, 숫자보다 먼저 볼 것

    비용표를 만들었으면 이제 끝이 아닙니다. 저는 아래 항목으로 검증합니다.

    1. 운영 1건당 처리 시간: VM 생성, 네트워크 추가, 증설 요청 처리 시간이 줄었는가
    2. 장애 복구 절차: 누가 어떻게 복구하는지 문서화되었는가
    3. 자동화 비율: 수작업 비율이 줄고 있는가
    4. 확장 시 단가 안정성: 노드가 늘어도 운영 복잡도가 감당 가능한가

    이 단계를 거치면 "OpenStack이 더 싸다"가 아니라 "우리 조직에서 OpenStack이 더 유리한 구조인가"로 질문이 바뀝니다. 이게 훨씬 정확합니다.

    제가 실제로 써봤을 때 느낀 건 이거였습니다. OpenStack의 진짜 비용 절감 포인트는 장기적인 표준화와 자동화입니다. 단기 전환만 보면 오히려 비용이 커 보일 수 있어요. 하지만 일정 규모 이상에서 운영 패턴이 정리되면, VMware 대안으로서 꽤 현실적인 선택지가 됩니다. 드디어 감이 잡히더라고요.

    OpenStack VMware TCO 3년 비용 비교 대시보드 이미지

    3년 기준 TCO 비교 결과를 대시보드 형태로 시각화한 예시 이미지입니다.

    8. 자주 묻는 질문 FAQ

    Q1. OpenStack이 무조건 VMware보다 저렴한가요?

    아닙니다. 조직의 운영 역량과 규모에 따라 다릅니다. 작고 단순한 환경에서는 상용 플랫폼이 더 경제적일 수도 있습니다.

    Q2. 프라이빗 클라우드 비용 비교에서 가장 많이 빠지는 항목은 뭔가요?

    대부분 인건비와 전환 안정화 비용이 빠집니다. 라이선스만 보면 판단이 틀어집니다.

    Q3. OpenStack 도입 전에 무엇부터 확인해야 하나요?

    현재 워크로드 분류, 네트워크 구조, 자동화 도구 사용 수준, 운영 인력 숙련도부터 점검하시는 게 좋습니다.

    Q4. 일부 워크로드만 OpenStack으로 옮기는 것도 괜찮나요?

    네, 오히려 현실적입니다. 개발/테스트 환경부터 시작해서 운영 모델을 검증하는 방식이 리스크를 줄여줍니다.

    9. 마무리: 비용 절감은 제품이 아니라 운영 모델에서 나옵니다

    정리해보면, OpenStack VMware TCO 분석의 핵심은 단순합니다. 라이선스 절감은 시작일 뿐이고, 진짜 승부는 운영 자동화, 표준화, 인력 구조에서 납니다. 저도 처음엔 숫자만 보고 판단하려다가 여러 번 돌아왔습니다. 근데 결국 남는 건 제품 이름이 아니라 운영 체계더라고요.

    혹시 지금 VMware 대안을 검토 중이시라면, 먼저 3년 기준 TCO 표를 직접 만들어보세요. 그리고 완전 전환보다 파일럿(Pilot, 시험 운영)부터 시작해보시는 걸 권합니다. 이거 진짜 중요합니다. 다음 글에서는 OpenStack 파일럿 환경을 최소 구성으로 설계하는 방법을 다뤄볼 예정입니다. 이전 글의 가상화 표준화 체크리스트도 같이 보시면 흐름이 더 잘 잡히실 겁니다.

    OpenStack과 VMware 선택 기준을 정리한 TCO 비교 인포그래픽

    어떤 조직에 OpenStack이 맞고 어떤 조직에 VMware가 더 적합한지 한눈에 정리한 요약 인포그래픽입니다.

    ✅ 한 줄 결론: OpenStack은 분명 강력한 VMware 대안입니다. 다만 실제 비용 절감 효과는 제품 그 자체보다, 그걸 운영하는 팀의 준비 상태에서 결정됩니다.

  • [OpenStack] Kolla-Ansible vs Native Install: 배포 방식 비교 분석

    [OpenStack] Kolla-Ansible vs Native Install: 배포 방식 비교 분석

    [OpenStack] Kolla-Ansible vs Native Install 배포 비교

    Kolla-Ansible OpenStack 배포를 처음 고민하시는 분들은 거의 비슷한 지점에서 막히시더라고요. 저도 처음엔 ‘그냥 패키지 설치해서 올리면 되는 거 아닌가?’ 싶었는데, 실제로 해보니 배포 방식에 따라 운영 난이도와 장애 대응 속도가 꽤 많이 달랐습니다. 특히 홈랩과 사내 테스트베드에서 OpenStack 설치 비교를 여러 번 해보니까, 처음 설계할 때의 선택이 나중에 진짜 크게 돌아오더라고요. 이번 글에서는 Kolla-Ansible과 Native Install(네이티브 설치, 직접 패키지와 서비스 단위로 구성) 방식을 경험 기준으로 차분히 비교해보겠습니다.

    혹시 지금 이런 상황이신가요? 빠르게 PoC(개념 검증, Proof of Concept)를 띄워야 하는데 운영 표준도 챙겨야 하고, 나중에 업데이트나 재배포도 염두에 두고 계신 분들 말입니다. 여기서 중요한 포인트는 단순히 ‘설치가 되느냐’가 아니라, 어떤 방식이 내 팀의 운영 역량과 더 잘 맞느냐입니다.

    컨테이너 기반 Kolla-Ansible과 패키지 기반 Native Install의 구조 차이를 한눈에 보여주는 비교 다이어그램입니다.

    Kolla-Ansible OpenStack 배포가 왜 주목받는지

    쉽게 말해 Kolla-Ansible은 OpenStack 서비스를 컨테이너(Container, 애플리케이션 실행 단위)로 배포하고, Ansible(앤서블, 에이전트 없이 원격 설정을 자동화하는 도구)로 전체 구성을 밀어 넣는 방식입니다. 반면 Native Install은 각 노드에 필요한 패키지를 직접 설치하고, 서비스 설정 파일을 손으로 맞추거나 배포 자동화 스크립트를 따로 관리하는 흐름에 가깝습니다.

    제가 직접 해보니 두 방식은 철학 자체가 다르더라고요. Kolla-Ansible은 표준화와 재현성에 강합니다. 반대로 Native Install은 세밀한 제어와 내부 이해에 강하죠. 처음엔 이게 뭔가 싶었는데, 몇 번 재설치를 반복하다 보니 왜 운영팀마다 선호 방식이 갈리는지 바로 이해됐습니다.

    • Kolla-Ansible: 컨테이너 기반, 역할 분리 명확, 재배포와 확장이 상대적으로 편함
    • Native Install: 서비스별 설정을 세밀하게 만질 수 있음, 학습에는 좋지만 운영 표준화가 어렵기 쉬움
    • 공통점: 결국 Neutron(뉴트론, 네트워크 서비스), Nova(노바, 컴퓨트 서비스), Keystone(키스톤, 인증 서비스) 같은 핵심 컴포넌트를 이해해야 안정적으로 굴러감

    OpenStack 설치 비교: 어떤 환경에 무엇이 맞을까

    이제 본론으로 들어가 보겠습니다. OpenStack 설치 비교를 할 때는 설치 편의성만 보면 안 됩니다. 운영 중 변경 작업, 장애 복구, 로그 추적, 업그레이드 전략까지 같이 봐야 하거든요. 저도 예전엔 설치만 되면 끝이라고 생각했었는데, 그 뒤에 남는 유지보수 비용이 더 크더라고요. 삽질 좀 했습니다 ㅎㅎ

    비교 항목 Kolla-Ansible Native Install
    배포 방식 컨테이너 이미지와 Ansible 플레이북 기반 패키지 설치와 서비스별 수동 설정 중심
    초기 진입 장벽 변수 구조와 네트워크 이해가 필요 설치 흐름은 단순해 보이지만 전체 의존성 파악이 어려움
    재현성 높음 운영자 숙련도에 따라 차이 큼
    문제 분석 컨테이너 로그와 Ansible 결과를 함께 봐야 함 서비스 단위 로그 확인은 직관적이나 변경 이력 관리가 어려움
    업데이트/재배포 자동화에 유리 절차 문서화가 부족하면 리스크 큼
    추천 환경 반복 배포, 표준화, 다노드 테스트베드 학습용, 디버깅 중심, 서비스 구조 파악 목적

    제 경험상 팀 단위 운영이라면 Kolla-Ansible 쪽이 훨씬 덜 힘들었습니다. 반면 OpenStack 내부 구조를 깊게 공부하려면 Native Install도 한 번은 꼭 해볼 만합니다. 왜냐하면 서비스가 어떤 순서로 붙고, 어디서 설정 충돌이 나는지 몸으로 익히게 되거든요.

    Ansible OpenStack 구성 관점에서 보는 핵심 차이

    1. 구성 관리 방식

    Kolla-Ansible은 보통 전역 설정과 서비스별 오버라이드(override, 기본 설정 덮어쓰기)를 분리해서 관리합니다. 이게 처음엔 조금 낯설어요. 하지만 실제로 써보니까 역할(Role)과 변수(Variable)가 정리돼 있어서, 나중에 다시 볼 때 덜 헷갈리더라고요.

    2. 네트워크 설계 난이도

    OpenStack은 네트워크에서 많이 넘어집니다. 관리망, 터널망, 외부망을 어떻게 나눌지에 따라 Neutron 구성이 완전히 달라지니까요. Native Install은 서비스 설정 파일을 직접 만지는 만큼 자유도는 높지만, 실수 한 번 하면 어디서부터 틀어졌는지 찾는 데 시간이 오래 걸렸습니다.

    3. 운영 표준화

    운영 문서가 중요한 조직이라면 OpenStack 배포 자동화 측면에서 Kolla-Ansible이 확실히 유리합니다. 인벤토리(inventory, 관리 대상 호스트 목록)와 변수 파일만 정리되면 재현성이 좋거든요. 이건 새 장비 들어왔을 때 정말 체감됩니다.

    Ansible OpenStack 구성과 노드 연결 구조를 보여주는 이미지

    컨트롤 노드, 컴퓨트 노드, 네트워크 노드 사이에서 Ansible과 컨테이너 서비스가 어떻게 연결되는지 보여주는 구성도입니다.

    실전 구현: Kolla-Ansible로 OpenStack 배포 기본 흐름

    이제 실전 쪽 이야기를 해보겠습니다. 여기서는 Kolla-Ansible OpenStack 배포의 전형적인 흐름을 예시로 보겠습니다. 배포판이나 릴리스에 따라 세부 패키지 이름은 조금 달라질 수 있으니, 실제 적용 전에는 운영 중인 환경 기준으로 문서를 꼭 맞춰보셔야 합니다. 저는 이런 식으로 접근하면 시행착오가 많이 줄더라고요.

    1. 배포용 제어 노드(Control Node)를 준비합니다.
    2. Ansible과 Kolla-Ansible을 설치합니다.
    3. 인벤토리와 전역 설정 파일을 작성합니다.
    4. 네트워크 인터페이스와 VIP(Virtual IP, 가상 IP)를 정의합니다.
    5. 사전 점검(prechecks)을 실행합니다.
    6. 배포 후 초기화와 검증을 진행합니다.

    1. 기본 패키지 준비

    python3 -m venv /opt/kolla-venv
    source /opt/kolla-venv/bin/activate
    pip install -U pip
    pip install 'ansible>=6,<9' kolla-ansible
    mkdir -p /etc/kolla

    여기서 중요한 포인트! Python 가상환경(virtual environment, 격리된 파이썬 실행 환경)을 써두면 나중에 의존성 꼬임이 줄어듭니다. 별거 아닌 것 같아도 이거 진짜 편하더라고요.

    2. 인벤토리 작성 예시

    all:
      hosts:
        controller01:
          ansible_host: 192.168.10.11
        compute01:
          ansible_host: 192.168.10.21
      children:
        control:
          hosts:
            controller01:
        network:
          hosts:
            controller01:
        compute:
          hosts:
            compute01:
        monitoring:
          hosts:
            controller01:
        storage:
          hosts:
            controller01:

    홈랩에서는 올인원 또는 2노드 구성으로 시작하는 경우가 많습니다. 저도 처음엔 욕심내서 역할을 너무 쪼갔다가 오히려 디버깅 포인트만 늘어났었네요. 처음에는 단순하게 가는 게 좋습니다.

    3. globals.yml 예시

    kolla_base_distro: "ubuntu"
    kolla_install_type: "source"
    openstack_release: "2023.2"
    kolla_internal_vip_address: "192.168.10.100"
    network_interface: "eth0"
    neutron_external_interface: "eth1"
    enable_haproxy: "yes"
    enable_cinder: "yes"
    enable_horizon: "yes"

    버전이나 배포판 조합은 실제 지원 매트릭스를 확인해서 맞추셔야 합니다. 제가 예전에 여기 대충 맞췄다가 컨테이너는 떠 있는데 서비스 등록이 꼬여서 한참 봤습니다. 드디어 됐다 싶으면 다른 데서 막히고, 그런 순간이 꼭 옵니다.

    4. 배포 실행

    kolla-ansible -i ./multinode bootstrap-servers
    kolla-ansible -i ./multinode prechecks
    kolla-ansible -i ./multinode deploy
    kolla-ansible -i ./multinode post-deploy

    이 순서대로 가면 됩니다. 특히 prechecks는 꼭 보셔야 해요. DNS, 시간 동기화, 인터페이스 정의 같은 기본 조건이 여기서 많이 걸립니다.

    5. OpenStack 클라이언트 환경 적용

    source /etc/kolla/admin-openrc.sh
    openstack service list
    openstack network agent list
    openstack hypervisor list

    여기까지 오면 1차 확인은 끝입니다. 서비스 카탈로그(Service Catalog, API 엔드포인트 목록)와 하이퍼바이저(Hypervisor, 가상화 호스트) 인식 상태를 먼저 보는 습관을 들이면 좋습니다.

    Kolla-Ansible OpenStack 배포 자동화 작업 중인 홈랩 환경 이미지

    Kolla-Ansible 배포 과정에서 사전 점검과 실제 배포가 진행되는 흐름을 홈랩 분위기로 표현한 이미지입니다.

    반대로 Native Install은 언제 유리할까

    그렇다고 Native Install이 무조건 불리한 건 아닙니다. 저도 실제로 써보니까 서비스 구조를 이해하는 데는 정말 도움이 컸습니다. 예를 들어 Keystone 설정이 어디서 인증 토큰 흐름에 영향을 주는지, Neutron ML2 플러그인(ML2 Plugin, 네트워크 드라이버 프레임워크)과 브리지 설정이 어떻게 맞물리는지 직접 보게 되거든요.

    특히 이런 경우엔 Native Install도 충분히 가치 있습니다.

    • 단일 노드 학습 환경을 빠르게 만들고 싶을 때
    • 컨테이너 추상화보다 서비스 파일과 로그를 직접 보고 싶을 때
    • 특정 컴포넌트의 동작을 깊게 디버깅해야 할 때
    • 자동화보다 구조 이해가 우선일 때

    다만 운영 관점에서는 사람이 바뀌거나 시간이 지나면 설정이 점점 꼬이기 시작합니다. 정말 많이 봤거든요. 문서가 조금만 부실해도 ‘이 설정 누가 왜 넣었지?’가 반복되더라고요.

    ⚠️ 주의사항과 트러블슈팅: 제가 실제로 막혔던 포인트

    1. 시간 동기화(NTP, Network Time Protocol) 문제

    OpenStack은 인증 토큰과 서비스 통신에서 시간 차이에 민감합니다. Kolla-Ansible이든 Native Install이든 노드 간 시간이 어긋나면 묘한 인증 실패가 납니다. 겉으로는 네트워크 문제처럼 보이는데, 알고 보면 시계 문제인 경우가 있더라고요.

    2. 네트워크 인터페이스 이름 불일치

    이건 홈랩에서 특히 자주 나옵니다. 예전 문서 보고 eth0, eth1으로 적어놨는데 실제 장비는 ens18, ens19인 경우요. 별거 아닌 오타 같은데 외부 네트워크 바인딩이 안 되고 Floating IP(플로팅 IP, 외부 접근용 가상 IP)도 꼬입니다.

    3. 컨테이너는 떠 있는데 서비스가 비정상

    Kolla-Ansible에서 흔히 겪는 착시입니다. docker ps나 podman ps 기준으로는 떠 있어도, 내부 서비스가 정상 등록되지 않았을 수 있습니다. 그래서 저는 항상 컨테이너 상태만 보지 않고 OpenStack API 응답까지 같이 확인합니다.

    4. Native Install의 설정 드리프트(Configuration Drift, 설정 불일치)

    처음엔 한 대에서 잘 되는데, 두 번째 노드부터 미묘하게 설정이 다르기 시작합니다. 결국 장애가 나면 원인 추적이 어려워져요. 여기서 중요한 포인트는 자동화되지 않은 반복 작업은 결국 누락을 만든다는 점입니다.

    • ⚠️ 사전 점검 체크리스트를 문서화하세요
    • ⚠️ 네트워크 맵과 인터페이스명을 먼저 확정하세요
    • ⚠️ 배포 직후 서비스 목록, 에이전트 목록, 하이퍼바이저 목록을 반드시 확인하세요
    • 💡 장애 분석 시에는 인프라 로그와 OpenStack API 결과를 같이 보세요

    검증과 결과 확인: 배포 후 무엇을 보면 되나

    Kolla-Ansible OpenStack 배포가 끝났다고 바로 안심하면 안 됩니다. 실제 검증은 이제부터거든요. 저는 보통 아래 순서로 확인합니다.

    1. Keystone 인증 정상 여부 확인
    2. Nova 컴퓨트 서비스 등록 확인
    3. Neutron 에이전트 상태 확인
    4. Horizon 대시보드 접속 확인
    5. 테스트 네트워크와 인스턴스 생성 확인
    source /etc/kolla/admin-openrc.sh
    openstack token issue
    openstack compute service list
    openstack network agent list
    openstack image list
    openstack server list

    실제로 써보니까 이 단계에서 가장 중요한 건 ‘서비스가 보이느냐’보다 ‘실제 워크로드가 도는가’였습니다. 테스트 인스턴스 하나 띄워보고, 네트워크 붙이고, 콘솔 접속까지 해보면 훨씬 확실합니다. 🎉

    OpenStack 배포 검증 결과와 Horizon 대시보드를 보여주는 이미지

    Horizon 대시보드와 CLI 결과를 통해 배포 성공 여부를 교차 검증하는 장면입니다.

    정리: 어떤 선택이 더 현실적인가

    결론부터 말씀드리면, 반복 가능한 운영 환경이 목표라면 Kolla-Ansible 쪽이 더 현실적입니다. 특히 팀 단위로 관리하거나 테스트베드를 여러 번 재현해야 한다면 OpenStack 배포 자동화의 장점이 확실히 드러납니다. 반면 Native Install은 구조 학습과 세밀한 디버깅에 강합니다. 저도 처음엔 Native Install로 내부를 익히고, 나중엔 Kolla-Ansible 쪽으로 운영 방식을 옮겨가는 흐름이 가장 자연스러웠습니다.

    혹시 지금 둘 중 하나를 선택해야 하는 상황이라면 이렇게 보시면 됩니다.

    • 빠른 표준화와 재배포가 필요하다면 Kolla-Ansible
    • OpenStack 내부 구조 학습이 우선이라면 Native Install
    • 장기 운영까지 본다면 자동화와 문서화가 쉬운 쪽을 선택

    다음 글에서는 Kolla-Ansible 환경에서 네트워크 분리와 외부망 연결, 특히 Neutron 브리지 구성을 조금 더 깊게 다뤄볼 예정입니다. 이전 글에서 다뤘던 리눅스 브리지와 VLAN 설계 내용을 같이 보시면 훨씬 이해가 빠르실 거예요.

    Kolla-Ansible OpenStack 배포와 Native Install 장단점 요약 인포그래픽

    두 배포 방식의 선택 기준과 운영 포인트를 빠르게 복습할 수 있도록 정리한 요약 인포그래픽입니다.

    자주 묻는 질문

    Q1. 처음 배우는 입장에서는 어떤 방식이 더 나을까요?

    OpenStack 구조를 제대로 익히고 싶다면 Native Install을 한 번 경험해보는 게 도움이 됩니다. 다만 실제 운영까지 바로 생각하신다면 Kolla-Ansible이 더 덜 고생스럽습니다.

    Q2. 홈랩에서는 어떤 쪽이 더 적합한가요?

    반복 실험이 많고 초기화 후 다시 띄우는 일이 잦다면 Kolla-Ansible이 편합니다. 반대로 서비스별 설정을 직접 뜯어보고 싶은 학습형 홈랩이라면 Native Install도 괜찮습니다.

    Q3. Ansible OpenStack 구성은 운영팀에도 유리한가요?

    네, 인벤토리와 변수 파일 기준으로 변경 이력을 관리하기 쉬워서 협업에 유리합니다. 특히 사람 손을 덜 타게 만드는 점이 큽니다.

    Q4. OpenStack 설치 비교에서 가장 먼저 봐야 할 기준은 뭔가요?

    설치 성공 여부보다 재현성, 운영 문서화, 장애 대응 흐름을 먼저 보시는 게 좋습니다. 결국 오래 남는 건 운영 부담이거든요.

  • [인프라] OpenStack 멀티노드 클러스터 1년 운영 회고

    [인프라] OpenStack 멀티노드 클러스터 1년 운영 회고

    [인프라] OpenStack 멀티노드 클러스터 1년 운영 회고

    OpenStack 멀티노드 운영을 1년 정도 굴려보면, 설치가 끝이라고 생각했던 시점부터 진짜 일이 시작되더라고요. 저도 처음엔 “컨트롤 플레인(control plane, 제어 영역)만 안정적이면 되겠지”라고 가볍게 봤었는데, 실제로 써보니까 네트워크, 스토리지, 메시지 큐(message queue, 비동기 작업 전달), 그리고 운영 절차가 전부 엮여 있어서 한 군데만 흔들려도 전체가 불안해졌습니다. 혹시 랩 환경(home lab, 개인 실험실)에서 잘 되던 구성이 운영 구간에서 갑자기 말을 안 들어서 당황하신 적 있으신가요? 오늘은 제가 직접 겪은 OpenStack 클러스터 후기, 그리고 OpenStack 배포 실패 사례까지 솔직하게 묶어서 정리해보겠습니다.

    이 글은 특정 배포판 홍보가 아니라, OpenStack 멀티노드 운영에서 실제로 부딪히는 포인트를 중심으로 썼습니다. 다음 글에서는 Ceph(세프, 분산 스토리지) 연동 쪽도 따로 다룰 예정이고, 이전 글에서 다뤘던 가상화 호스트 설계 내용이 있다면 함께 보시면 흐름이 더 잘 잡히실 겁니다.

    컨트롤 노드, 컴퓨트 노드, 네트워크 경로가 한눈에 보이는 OpenStack 멀티노드 운영 아키텍처 예시입니다.

    왜 OpenStack 멀티노드 운영은 설치보다 운영이 더 어렵나

    쉽게 말해 OpenStack은 하나의 프로그램이 아니라 여러 서비스의 연합체더라고요. Keystone(키스톤, 인증), Nova(노바, 컴퓨트), Neutron(뉴트론, 네트워크), Glance(글랜스, 이미지), Cinder(신더, 블록 스토리지) 같은 서비스가 각자 잘 떠 있어야 하고, 서로 API 호출도 정상이어야 합니다. 설치 문서는 대부분 “어떻게 올릴까”에 집중하는데, 운영은 “문제가 났을 때 어디부터 볼까”가 핵심이거든요.

    제가 1년 운영하면서 느낀 건 딱 세 가지였습니다.

    • 장애는 단일 원인처럼 보이지만 실제론 연쇄 장애인 경우가 많습니다.
    • 성능 문제보다 상태 일관성(state consistency, 서비스 간 상태 맞춤) 문제가 더 까다롭습니다.
    • 사람이 반복하는 운영 작업은 결국 사고로 이어집니다.

    예를 들어 인스턴스(instance, 가상 머신) 생성 실패가 떴다고 해서 꼭 Nova 문제는 아니었습니다. 메시지 브로커(broker, 중간 전달자) 지연, Neutron 포트 생성 실패, 데이터베이스 연결 수 부족 같은 식으로 옆 서비스 이슈가 튀어나오는 경우가 꽤 많았거든요. 처음엔 이게 뭔가 싶었는데, 로그를 몇 번 따라가다 보면 OpenStack은 결국 관계도 싸움이라는 걸 알게 됩니다.

    운영 전에 잡아야 했던 기본 원칙

    여기서 중요한 포인트! OpenStack 멀티노드 운영은 기술 스택보다 운영 원칙을 먼저 정하는 게 훨씬 중요합니다. 저는 초반에 이걸 대충 잡았다가 삽질 좀 했습니다 ㅎㅎ

    영역 초기 생각 1년 뒤 결론
    네트워크 가능하면 단순하게 관리망, 스토리지망, 테넌트망 분리가 운영 피로를 줄임
    스토리지 일단 붙으면 된다 장애 복구 절차와 성능 특성까지 같이 봐야 함
    로그 문제 생기면 그때 확인 중앙 수집 없으면 원인 추적 시간이 급격히 늘어남
    배포 처음 한 번만 성공하면 됨 재현 가능한 자동화가 없으면 다음 장애 때 무너짐
    모니터링 CPU, 메모리만 보면 됨 API 지연, 큐 적체, DB 연결 상태까지 봐야 함

    특히 네트워크는 정말 중요했습니다. Neutron이 들어가는 순간 브리지(bridge, 가상 스위치), VLAN(가상 랜), 오버레이 네트워크(overlay network, 가상 터널 네트워크) 이해도가 부족하면 “핑은 되는데 VM 통신은 안 됨” 같은 상황이 자주 생깁니다. 이거 진짜 사람 멘탈 흔듭니다.

    제가 실제로 사용한 운영 구조와 체크 포인트

    구성 자체는 전형적인 멀티노드 방식이었습니다. 컨트롤 노드에 API와 스케줄러 계열을 두고, 컴퓨트 노드에서 하이퍼바이저(hypervisor, 가상화 실행 계층)를 돌리고, 네트워크는 별도 역할을 분리하거나 최소한 경로를 명확히 나눴습니다. 여기에 MariaDB(마리아디비, 관계형 데이터베이스), RabbitMQ(래빗엠큐, 메시지 큐), HAProxy(에이치에이프록시, 로드밸런서)를 조합하면 기본 뼈대는 갖춰집니다.

    배포 자동화는 도구마다 방식이 다르지만, 원칙은 비슷합니다.

    1. 호스트 이름과 DNS를 먼저 고정합니다.
    2. NTP 또는 Chrony로 시간 동기화를 맞춥니다.
    3. 관리망 IP와 서비스 엔드포인트(endpoint, 서비스 접속 주소)를 문서화합니다.
    4. 메시지 큐와 데이터베이스 상태를 먼저 확인합니다.
    5. 그다음 OpenStack 서비스 등록과 에이전트(agent, 백그라운드 작업 프로세스) 상태를 검증합니다.

    제가 자주 쓰던 점검 명령은 이런 식이었습니다.

    openstack service list
    openstack endpoint list
    openstack compute service list
    openstack network agent list
    openstack hypervisor list
    openstack server list --all-projects
    

    처음엔 서비스 목록만 보고 안심했었는데, 실제로는 에이전트가 살아 있어도 기능이 망가진 경우가 있더라고요. 그래서 저는 아래처럼 시스템 레벨도 꼭 같이 확인했습니다.

    systemctl --type=service | grep -E 'nova|neutron|cinder|glance|keystone'
    ss -lntp
    journalctl -u nova-compute -n 100
    journalctl -u neutron-server -n 100
    rabbitmqctl list_queues
    mysql -e 'show processlist;'
    

    여기서 핵심은 “OpenStack 명령 결과”와 “OS 레벨 상태”를 분리해서 보는 겁니다. 둘 중 하나만 보면 꼭 놓치는 구간이 생깁니다.

    OpenStack 멀티노드 운영 서비스 흐름 구성 이미지

    Keystone, Nova, Neutron, RabbitMQ, MariaDB가 어떤 흐름으로 연결되는지 설명하는 구성 다이어그램 위치입니다.

    실전 구현에서 효과 있었던 운영 습관

    프로덕션 OpenStack 회고 관점에서 보면, 기술보다 습관이 더 오래 남습니다. 제가 1년 동안 남긴 것 중 실제로 가장 도움이 됐던 건 아래 네 가지였습니다.

    1. 변경 작업 전 체크리스트 작성
      패키지 업데이트, 네트워크 설정 변경, 서비스 재시작 전후 확인 항목을 고정했습니다.
    2. 설정 파일 차이(diff, 변경점) 기록
      나중에 왜 바꿨는지 기억이 안 나는 순간이 오거든요.
    3. 장애 재현 메모
      증상, 원인 후보, 실제 원인, 해결 순서를 남겨두면 다음 장애 때 시간이 확 줄어듭니다.
    4. 작은 자동화라도 바로 적용
      반복 명령은 셸 스크립트(shell script, 명령 자동화)로 묶었습니다.

    예를 들면 컴퓨트 노드 상태 점검은 간단한 스크립트로 묶어두면 꽤 편합니다.

    #!/usr/bin/env bash
    set -eu
    
    echo '[1] hypervisor list'
    openstack hypervisor list
    
    echo '[2] compute services'
    openstack compute service list
    
    echo '[3] failed services'
    systemctl --failed
    
    echo '[4] recent nova-compute logs'
    journalctl -u nova-compute -n 50 --no-pager
    

    이런 건 거창하지 않아도 됩니다. 중요한 건 사람 손을 덜 타게 만드는 것입니다. 제가 직접 해보니 OpenStack 배포 실패 사례 중 꽤 많은 비율이 설치 자체보다, 설치 후 운영 절차 부재에서 시작됐습니다.

    ⚠️ 실제로 크게 데였던 장애와 해결 과정

    1. 메시지 큐 지연으로 인한 인스턴스 생성 실패

    증상은 단순했습니다. VM 생성 요청은 들어가는데 완료가 안 되는 겁니다. 처음엔 Nova 스케줄러를 의심했는데, 로그를 따라가 보니 RabbitMQ 큐 적체가 원인이었습니다. 관리망 지연이 누적되면서 RPC(Remote Procedure Call, 원격 호출) 응답이 늦어졌고, 결국 타임아웃이 연쇄적으로 터졌습니다.

    • 배운 점: API 장애처럼 보여도 메시지 경로를 꼭 봐야 합니다.
    • 해결 방법: 큐 상태 확인, 관리망 상태 점검, 재시작 순서 표준화

    2. Neutron 포트 생성은 되는데 통신이 안 되는 문제

    이건 정말 오래 잡았습니다. 보안 그룹(security group, 가상 방화벽) 문제처럼 보였는데, 실제로는 브리지 매핑(bridge mapping, 네트워크 연결 규칙)과 물리 NIC 연결 정의가 어긋나 있었습니다. 로그상 큰 에러가 안 보여서 더 헷갈렸고요. 저도 처음엔 헷갈렸는데, 결국 에이전트 설정과 호스트 네트워크 구성이 서로 맞아야 한다는 너무 당연한 사실을 다시 배웠습니다.

    • 배운 점: Neutron 문제는 논리 설정과 물리 연결을 같이 봐야 합니다.
    • 해결 방법: 브리지 이름, 인터페이스 매핑, 에이전트 상태를 한 번에 점검

    3. 스토리지 연결은 되는데 성능이 들쭉날쭉한 상황

    이건 더 무서운 유형입니다. 완전히 죽는 게 아니라 “어제는 괜찮았는데 오늘은 왜 느리지?”가 반복되거든요. 결국 원인은 백엔드 스토리지 경로 경쟁, 작업 몰림, 그리고 이미지 캐시 처리 타이밍이 겹친 문제였습니다. 숫자를 괜히 지어내고 싶진 않아서 구체 수치는 빼겠지만, 체감 성능 차이는 꽤 컸습니다.

    • 배운 점: 스토리지는 붙어 있는지만 보지 말고 패턴을 봐야 합니다.
    • 해결 방법: 작업 시간대 분산, 캐시 정책 점검, 백엔드 모니터링 강화

    4. 데이터베이스는 살아 있는데 API가 간헐적으로 느린 문제

    이건 딱 “다 살아 있는데 왜 느리지?” 케이스였네요. DB 연결 수, 느린 쿼리(slow query, 지연 질의), 서비스 재시도 패턴이 겹치면서 간헐 지연이 생겼습니다. 이런 문제는 재시작으로 잠깐 가려질 수 있어서 더 위험합니다. 드디어 됐다! 싶었는데 다음날 다시 터지더라고요.

    정리하면, OpenStack 멀티노드 운영에서 가장 위험한 장애는 완전 다운보다 반쯤 되는 장애입니다. 운영자가 방심하기 쉽거든요.

    OpenStack 멀티노드 운영 장애 분석 관제 화면

    로그 추적, 큐 적체 확인, 네트워크 흐름 분석을 한 번에 보여주는 운영 관제 이미지 위치입니다.

    문제 줄이기 위해 정착시킨 검증 절차

    문제가 생긴 뒤 고치는 것도 중요하지만, 더 중요한 건 변경 후 검증입니다. 저는 아래 순서로 체크했습니다.

    1. 인증 확인: 토큰 발급과 서비스 카탈로그(service catalog, 서비스 목록) 확인
    2. 컴퓨트 확인: 하이퍼바이저 목록과 서비스 up/down 상태 확인
    3. 네트워크 확인: 네트워크 생성, 서브넷 연결, 포트 생성 테스트
    4. 부팅 확인: 테스트 인스턴스 생성 후 콘솔 접속 확인
    5. 삭제 확인: 인스턴스 삭제, 볼륨 정리, 포트 잔존 여부 확인

    간단한 검증 흐름 예시는 이렇습니다.

    openstack token issue
    openstack network create lab-net
    openstack subnet create --network lab-net --subnet-range 192.168.50.0/24 lab-subnet
    openstack server create --flavor m1.small --image test-image --network lab-net test-vm
    openstack server list
    openstack console url show test-vm
    

    여기서 중요한 건 생성만 보는 게 아니라 삭제와 정리까지 확인하는 겁니다. 리소스 찌꺼기(resource orphan, 고아 리소스)가 쌓이기 시작하면 나중에 장애 분석이 훨씬 더 어려워집니다.

    1년 운영 후 남은 성과와 아쉬움

    🎉 성과부터 말하면, 운영 초반보다 장애 대응 시간이 눈에 띄게 줄었습니다. 원인은 대단한 튜닝이 아니라, 로그 보는 순서와 점검 절차가 정리됐기 때문이었습니다. OpenStack 클러스터 후기를 한 줄로 줄이면 이겁니다. 복잡성은 줄이지 못해도, 복잡성을 다루는 방법은 개선할 수 있다.

    반대로 아쉬움도 분명했습니다.

    • 초기 아키텍처 문서를 너무 늦게 정리했습니다.
    • 네트워크 변경 이력을 더 일찍 표준화했어야 했습니다.
    • 테스트 환경과 운영 환경 차이를 가볍게 보면 안 됐습니다.
    • “지금 되니까 괜찮다”는 판단이 가장 위험했습니다.

    특히 프로덕션 OpenStack 회고를 하면서 느낀 건, 운영자는 문제를 해결하는 사람인 동시에 문제가 다시 생기지 않게 만드는 사람이어야 한다는 점이었습니다. 근데 이게 말처럼 쉽진 않죠. 문서화는 귀찮고, 자동화는 미루기 쉽고, 장애는 꼭 바쁠 때 옵니다.

    OpenStack 멀티노드 운영 안정화 결과 요약 인포그래픽

    운영 절차 정리 전후의 안정화 흐름과 핵심 교훈을 비교하는 요약 시각화 이미지 위치입니다.

    OpenStack 멀티노드 운영 정리: 지금 다시 시작한다면

    💡 제가 지금 다시 처음부터 OpenStack 멀티노드 운영을 구성한다면 아래 순서로 갑니다.

    1. 네트워크 분리 설계부터 문서화합니다.
    2. 배포 자동화를 처음부터 전제로 둡니다.
    3. 공통 로그와 모니터링을 설치 초기에 붙입니다.
    4. 테스트 VM 생성/삭제 검증을 표준 절차로 만듭니다.
    5. 장애 기록 템플릿을 운영 첫날부터 사용합니다.

    이 다섯 개만 지켜도 OpenStack 배포 실패 사례의 상당수를 예방할 수 있습니다. 물론 환경마다 디테일은 다를 겁니다. 그래도 뼈대는 비슷하더라고요. 특히 OpenStack 멀티노드 운영은 “한 번 설치 성공”보다 “열 번 재현 가능”이 훨씬 값집니다.

    자주 묻는 질문

    Q1. 홈랩에서도 멀티노드가 의미가 있나요?

    있습니다. 오히려 작은 환경에서 역할 분리와 장애 흐름을 이해하기 좋습니다. 다만 과한 고가용성(HA, 고장 대비 이중화)보다는 기본 동작과 복구 절차부터 익히는 게 낫습니다.

    Q2. 가장 먼저 모니터링해야 할 것은 뭔가요?

    CPU나 메모리보다 먼저 API 응답 지연, 메시지 큐 적체, 데이터베이스 연결 상태, 네트워크 에이전트 상태를 보시는 걸 권합니다.

    Q3. 설치 도구보다 중요한 건 뭔가요?

    운영 문서, 변경 이력, 검증 절차입니다. 도구는 바꿀 수 있지만 운영 습관은 쉽게 안 바뀌거든요.

    마무리

    1년 동안 OpenStack 멀티노드 클러스터를 운영하면서 느낀 건, OpenStack은 화려한 기능보다 기본기가 훨씬 중요하다는 점이었습니다. 서비스 간 관계를 이해하고, 장애를 추적하는 순서를 만들고, 변경을 기록하는 것. 이 세 가지가 결국 운영 품질을 갈랐습니다. 저도 처음엔 “왜 이렇게 복잡하지?” 싶었는데, 하나씩 뜯어보니 결국 시스템은 거짓말을 안 하더라고요.

    혹시 지금 OpenStack 멀티노드 운영을 준비 중이시라면, 설치 성공 화면에서 끝났다고 생각하지 마시고 검증 절차부터 붙여보세요. 그게 나중에 가장 큰 차이를 만듭니다. 다음 글에서는 스토리지 연동과 백업 전략 쪽을 더 현실적으로 풀어보겠습니다. ✅