13년차의 서버실

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

[태그:] Pulumi

  • [Cloud] 기존 인프라를 Pulumi로 전환하기: 마이그레이션 전략 및 체크리스트

    [Cloud] 기존 인프라를 Pulumi로 전환하기: 마이그레이션 전략 및 체크리스트

    안녕하세요, 13년차의 서버실 운영자입니다. 오늘은 많은 인프라 엔지니어분들이 한 번쯤 고민해봤을 주제, 기존 인프라를 Pulumi(풀루미)로 전환하는 마이그레이션 전략에 대해 이야기해보려고 해요.

    혹시 지금도 수동으로 서버를 만들고, 설정 변경할 때마다 손으로 클릭하거나 스크립트를 돌리고 계신가요? 처음엔 괜찮았는데, 인프라가 커질수록 관리하기 너무 힘들잖아요. 저도 그랬거든요. 예전에는 직접 하나하나 다 세팅했었는데, 시간이 지나니 너무 비효율적이라는 걸 깨달았어요. 그러다 IaC(Infrastructure as Code, 코드형 인프라)에 관심을 가지게 되었고, 특히 Pulumi를 접하면서 기존 인프라를 코드로 관리하는 것에 매력을 느꼈습니다. 기존 인프라를 Pulumi로 마이그레이션(Migration)하는 과정이 쉽지는 않았지만, 그만큼 얻는 것이 많았기에 제 경험을 공유하고 싶었어요.

    이 글을 통해 여러분의 Pulumi 도입과 IaC 전환에 도움이 될 만한 실질적인 전략과 마이그레이션 체크리스트를 함께 살펴보겠습니다. 삽질했던 경험도 솔직하게 풀어낼 테니, 비슷한 고민을 하고 계신다면 분명 도움이 될 거예요. 자, 그럼 시작해볼까요?

    수동 인프라와 Pulumi 코드형 인프라 비교 다이어그램

    수동으로 관리되는 복잡한 인프라와 Pulumi로 코드화되어 정돈된 인프라의 개념적인 비교 다이어그램입니다.

    Pulumi, 왜 도입해야 할까요? IaC 전환의 필요성

    우선, Pulumi가 정확히 무엇이고 왜 우리가 굳이 기존 인프라를 Pulumi로 전환(Pulumi Migration)해야 하는지 간단하게 짚고 넘어가 볼까요?

    Pulumi(풀루미)는 Python, TypeScript, Go, C# 같은 익숙한 프로그래밍 언어로 클라우드 인프라를 코드로 정의하고 배포할 수 있는 IaC(Infrastructure as Code, 코드형 인프라) 도구예요. 쉽게 말해, AWS EC2 인스턴스나 S3 버킷 같은 리소스들을 CLI(Command Line Interface)나 콘솔에서 직접 만드는 게 아니라, Python 스크립트처럼 코드로 작성해서 관리하는 거죠.

    제가 처음 Pulumi를 써봤을 때 가장 인상 깊었던 건, 기존 프로그래밍 언어의 강점을 그대로 가져온다는 점이었어요. 조건문, 반복문, 함수 같은 일반적인 프로그래밍 로직을 인프라 코드에 적용할 수 있으니 훨씬 유연하고 강력하게 인프라를 관리할 수 있더라고요. Terraform(테라폼)도 훌륭한 IaC 도구지만, HCL(HashiCorp Configuration Language)이라는 자체 언어를 배워야 했거든요. Pulumi는 제가 이미 아는 언어로 인프라를 다룰 수 있다는 게 정말 큰 장점이었어요.

    그럼 왜 IaC로 전환(IaC 전환)해야 할까요? 기존 인프라가 잘 돌아가고 있는데 굳이 건드려야 하나 싶을 수도 있어요. 하지만 IaC는 다음과 같은 명확한 이점을 제공합니다.

    • 일관성(Consistency): 코드로 정의되니 휴먼 에러가 줄어들고, 항상 동일한 환경을 배포할 수 있어요.
    • 반복 가능성(Repeatability): 개발, 스테이징, 프로덕션 환경을 똑같이 빠르게 구축할 수 있습니다.
    • 버전 관리(Version Control): Git(깃) 같은 VCS(Version Control System)로 인프라 변경 이력을 추적하고, 필요하면 롤백(Rollback)도 가능해져요.
    • 협업(Collaboration): 여러 엔지니어가 함께 인프라를 정의하고 검토할 수 있습니다.
    • 재사용성(Reusability): 공통 모듈을 만들어 인프라 배포 시간을 단축할 수 있죠.

    이런 장점들 때문에 기존 인프라를 인프라 코드화하는 건 이제 선택이 아닌 필수가 되어가고 있어요.

    기존 인프라 Pulumi 마이그레이션 전략 및 체크리스트

    자, 이제 본론으로 들어와서, 기존에 수동으로 구축된 인프라를 Pulumi로 마이그레이션(Migration)하는 구체적인 전략과 제가 직접 겪으면서 만들어 본 체크리스트(Checklist)를 공유해 드릴게요. 한 번에 모든 걸 바꾸려고 하면 대혼란이 올 수 있으니, 점진적인 접근이 중요합니다.

    1. 사전 준비 및 환경 설정 (Pre-requisites & Setup)

    가장 먼저 Pulumi를 사용할 환경을 구축해야겠죠? 제 경험상 이 단계에서 꼼꼼하게 준비해야 나중에 삽질을 줄일 수 있더라고요.

    1. Pulumi CLI 설치: 운영체제에 맞는 Pulumi CLI를 설치합니다.
      curl -fsSL https://get.pulumi.com | sh
    2. 클라우드 프로바이더 인증 설정: AWS, Azure, GCP 등 여러분이 사용하는 클라우드에 Pulumi가 접근할 수 있도록 인증 정보를 설정해야 합니다. 예를 들어 AWS의 경우, ~/.aws/credentials 파일이나 환경 변수를 통해 설정하죠.
    3. 프로젝트 생성 및 초기화: Pulumi 프로젝트를 생성하고 사용할 언어를 선택합니다. 저는 주로 TypeScript나 Python을 사용하는데, 여기서는 Python을 예시로 들어볼게요.
      mkdir my-pulumi-infra
      cd my-pulumi-infra
      pulumi new python

      이 명령어를 실행하면 기본 템플릿 파일들이 생성됩니다.

    4. 백엔드 상태 저장소 결정: Pulumi는 인프라의 상태(State)를 관리하는데, 이 상태 파일을 어디에 저장할지 결정해야 합니다. 기본적으로 Pulumi Service(클라우드)에 저장되지만, AWS S3나 Azure Blob Storage 같은 자체 스토리지를 사용할 수도 있습니다. 프로덕션 환경에서는 자체 스토리지를 권장해요.

    2. 리소스 임포트 전략 (Resource Import Strategy)

    기존 인프라를 Pulumi로 가져오는 가장 중요한 단계입니다. Pulumi는 이미 존재하는 리소스를 코드로 임포트(Import)하는 기능을 제공하는데, 이게 정말 유용하더라고요. 수동으로 하나하나 코드를 작성하는 것보다 훨씬 빠르고 정확합니다.

    제가 해보니, 한 번에 모든 리소스를 임포트하는 것보다는 작은 단위로 쪼개서 임포트하는 것이 훨씬 안전하고 관리하기 편했습니다. 예를 들어 VPC(Virtual Private Cloud), 서브넷(Subnet), 보안 그룹(Security Group)부터 먼저 임포트하고, 그다음에 EC2 인스턴스, RDS(Relational Database Service) 데이터베이스 순으로 진행하는 식이죠.

    1. 임포트할 리소스 식별: 마이그레이션할 인프라 리스트를 작성하고, 어떤 순서로 임포트할지 우선순위를 정합니다. 의존성(Dependency)이 낮은 리소스부터 시작하는 게 좋아요.
    2. 임포트 대상 리소스 ID 확인: 클라우드 콘솔이나 CLI에서 각 리소스의 ID(또는 ARN)를 확인합니다. 이 ID는 임포트 명령에 필요해요.
    3. Pulumi 임포트 코드 작성 및 실행: Pulumi는 pulumi import 명령어를 통해 기존 리소스를 가져올 수 있습니다.
    # my_pulumi_infra/__main__.py 에 임포트할 리소스 코드를 먼저 작성합니다.
    import pulumi_aws as aws
    
    # 이 리소스는 아직 실제 AWS에 존재하지 않습니다.
    # 임포트를 위해 임시로 코드를 작성하고, 실제 리소스 ID를 지정해야 합니다.
    my_vpc = aws.ec2.Vpc("my-existing-vpc",
        cidr_block="10.0.0.0/16",
        # 기타 속성들은 실제 VPC의 속성과 일치시켜야 합니다.
        # 예를 들어, tags={ "Name": "my-existing-vpc" } 등
    )
    
    # 임포트 명령 실행 예시 (터미널에서)
    # pulumi import aws:ec2/vpc:Vpc my-existing-vpc vpc-xxxxxxxxxxxxxxxxx
    # 여기서 'vpc-xxxxxxxxxxxxxxxxx'는 실제 AWS VPC의 ID입니다.
    

    pulumi import 명령을 실행하면 Pulumi가 해당 리소스의 현재 상태를 읽어와서 __main__.py 파일에 코드를 생성해 줍니다. 이 코드를 기반으로 Pulumi 스택(Stack)과 클라우드 리소스 간의 상태가 동기화되는 거죠. 이 과정에서 diff(차이점)를 잘 확인하는 게 중요해요.

    Pulumi 기존 리소스 임포트 과정 플로우차트

    Pulumi CLI를 이용해 기존 클라우드 리소스를 코드로 임포트하는 과정의 흐름을 보여주는 플로우차트입니다.

    3. 코드 리팩토링 및 모듈화 (Code Refactoring & Modularization)

    임포트된 코드는 보통 원시적인 형태입니다. 이걸 그대로 사용하는 것보다는 리팩토링(Refactoring)하고 모듈화(Modularization)하는 과정이 꼭 필요해요.

    1. 하드코딩된 값 제거: IP 주소, 리소스 이름 등 하드코딩된 값들을 pulumi.Config나 변수로 분리하여 유연성을 높입니다.
    2. 재사용 가능한 모듈 생성: VPC, 네트워크 구성, 공통 보안 그룹 등 여러 스택에서 재사용될 수 있는 부분은 별도의 모듈(예: Python 파일)로 분리합니다. 이렇게 하면 코드가 훨씬 깔끔해지고 유지보수가 쉬워집니다.
      # modules/network.py 예시
      import pulumi_aws as aws
      
      def create_vpc(name: str, cidr_block: str):
          vpc = aws.ec2.Vpc(name, cidr_block=cidr_block)
          # 서브넷, 인터넷 게이트웨이 등 추가 생성 로직
          return vpc
      
      # my_pulumi_infra/__main__.py 에서 사용
      # from .modules import network
      # my_vpc = network.create_vpc("my-app-vpc", "10.0.0.0/16")
      
    3. Pulumi 컴포넌트 리소스 활용: 복잡한 인프라 패턴을 추상화하고 싶다면 Pulumi 컴포넌트 리소스(Component Resources)를 직접 만들어 사용하는 것도 좋은 방법입니다. 여러 개의 기본 리소스를 하나의 논리적인 단위로 묶을 수 있거든요.

    4. 테스트 및 검증 (Testing & Validation)

    코드 리팩토링 후에는 반드시 테스트(Testing)를 거쳐야 합니다. 특히 기존에 잘 운영되던 서비스에 영향을 주면 안 되니까요.

    1. Dry Run (pulumi preview): pulumi preview 명령어를 통해 실제 변경 사항이 어떻게 적용될지 미리 확인합니다. 이 단계에서 예상치 못한 변경이 없는지 꼼꼼하게 검토해야 합니다. ⚠️
    2. Staging 환경 배포: 프로덕션 환경에 바로 적용하기보다는, 최대한 프로덕션과 유사한 스테이징(Staging) 환경에 먼저 배포해보고 문제가 없는지 철저히 검증합니다.
    3. 서비스 영향도 최소화: 마이그레이션 중 서비스 중단이 불가피하다면, 다운타임(Downtime)을 최소화할 수 있는 전략(예: Blue/Green Deployment, Canary Deployment)을 고려해야 합니다.

    ⚠️ Pulumi 마이그레이션 시 주의사항 및 삽질 경험

    제가 13년간 인프라를 만져보면서 느낀 건데, 항상 계획대로만 되는 건 아니더라고요. Pulumi 마이그레이션(Migration) 과정에서도 예상치 못한 문제들이 발생했습니다. 몇 가지 주의사항(Caveats)과 제가 삽질(Troubleshooting)했던 경험을 공유해 드릴게요.

    • 상태 불일치 (State Drift): 가장 흔한 문제 중 하나입니다. Pulumi가 관리하는 코드 상태와 실제 클라우드 리소스 상태가 달라지는 경우죠. 예를 들어, Pulumi 코드를 배포한 후에 누군가 수동으로 AWS 콘솔에서 보안 그룹 설정을 변경했다면, 다음 pulumi up 실행 시 Pulumi는 이 변경 사항을 되돌리려고 할 수 있습니다. 이걸 막으려면 Pulumi가 관리하는 리소스는 절대로 수동으로 변경하지 않도록 팀원들과 약속해야 합니다. 만약 상태 불일치가 발생하면, pulumi refresh 명령으로 현재 클라우드 상태를 읽어와 Pulumi 스택 상태를 업데이트하거나, pulumi state delete 후 다시 임포트하는 등의 방법을 사용해야 합니다.
    • 의존성 문제 (Dependency Issues): 리소스 간의 의존성을 Pulumi가 정확히 파악하지 못해서 배포 순서가 꼬이는 경우가 가끔 있었습니다. 특히 복잡한 네트워크 구성에서 이런 문제가 발생하더라고요. 이럴 때는 depends_on 옵션을 명시적으로 사용해서 의존성을 지정해 주면 해결할 수 있습니다.
      my_resource_b = aws.some.ResourceB("my-resource-b",
          # ...
          opts=pulumi.ResourceOptions(depends_on=[my_resource_a])
      )
      
    • 기존 리소스 삭제 위험: pulumi import를 잘못 사용하거나, 임포트 후 코드를 수정하는 과정에서 기존 리소스가 삭제될 수 있다는 경고를 보지 못하고 진행했던 적이 있어요. 😱 항상 pulumi preview 결과를 꼼꼼히 확인하고, 삭제(Delete) 또는 교체(Replace) 작업이 있다면 다시 한번 심사숙고해야 합니다. 특히 프로덕션 환경에서는 더욱 조심해야겠죠.
    • 권한 문제: Pulumi CLI를 실행하는 계정이 필요한 클라우드 리소스에 대한 모든 권한을 가지고 있지 않아 배포가 실패하는 경우가 많았습니다. 특히 IAM(Identity and Access Management) 정책이 복잡할 때 자주 발생하더라고요. 최소한의 권한(Least Privilege) 원칙은 중요하지만, 마이그레이션 초기에는 필요한 권한을 충분히 부여하고, 안정화된 후에 점진적으로 줄여나가는 전략도 고려해 볼 만합니다.

    이런 삽질들을 겪으면서 Pulumi 마이그레이션(Pulumi Migration)은 기술적인 부분만큼이나 프로세스(Process)와 팀원 간의 소통(Communication)이 중요하다는 걸 깨달았습니다. 항상 변경 사항을 공유하고, 리뷰하는 과정을 거치는 것이 중요해요.

    마이그레이션 완료 후 검증 및 관리

    성공적으로 Pulumi 마이그레이션(Pulumi Migration)을 마쳤다면, 이제 모든 것이 제대로 작동하는지 검증(Validation)해야 합니다. 그리고 앞으로 Pulumi로 관리되는 인프라를 어떻게 운영할지에 대한 계획도 세워야겠죠?

    1. Pulumi 스택 상태 확인: pulumi stack ls, pulumi stack select <stack_name>, pulumi stack output 명령어를 통해 현재 스택의 상태와 배포된 리소스 정보를 확인합니다.
    2. 클라우드 리소스 확인: 실제 클라우드 콘솔이나 CLI에서 Pulumi가 배포한 리소스들이 의도한 대로 생성되고 설정되었는지 다시 한번 확인합니다. 불필요한 리소스가 남아있지는 않은지도 확인해야 해요.
    3. 모니터링 연동: 기존에 사용하던 모니터링 시스템(예: Prometheus, Grafana, CloudWatch)과 Pulumi로 배포된 리소스들이 제대로 연동되어 데이터를 수집하고 있는지 확인합니다.
    4. CI/CD 파이프라인 구축: Pulumi 코드를 Git 저장소에 올리고, CI/CD(Continuous Integration/Continuous Delivery) 파이프라인을 구축하여 코드 변경 시 자동으로 pulumi preview, pulumi up이 실행되도록 자동화하는 것이 좋습니다. 제가 직접 해보니, 이렇게 자동화했을 때 인프라 배포 속도와 안정성이 엄청나게 향상되더라고요.
    Pulumi 클라우드 리소스 관리 대시보드 예시

    Pulumi를 통해 배포 및 관리되는 클라우드 리소스들의 현황을 한눈에 볼 수 있는 가상의 대시보드 화면입니다.

    마이그레이션을 마치며: Pulumi와 함께 성장하기

    지금까지 기존 인프라를 Pulumi로 전환(Pulumi 마이그레이션)하는 전략과 제가 겪었던 경험들을 공유해 드렸습니다. 처음에는 낯선 IaC 도구와 씨름하는 것이 쉽지 않게 느껴질 수 있어요. 저도 처음엔 기존 스크립트나 수동 작업에 익숙해서 ‘이걸 언제 다 코드로 바꾸나’ 막막했었거든요. 하지만 한 번 전환하고 나니, 인프라 관리가 훨씬 수월해지고, 개발 생산성(Developer Productivity)도 눈에 띄게 좋아지는 걸 체감할 수 있었습니다.

    Pulumi 도입(Pulumi 도입)은 단순히 도구 하나를 바꾸는 것을 넘어, 인프라를 바라보는 관점을 바꾸는 중요한 과정이라고 생각합니다. 코드로 인프라를 정의하고 관리함으로써, 우리는 더 예측 가능하고, 안정적이며, 확장 가능한 시스템을 구축할 수 있게 되죠. 인프라 코드화의 여정은 계속될 거예요.

    이 글이 여러분의 Pulumi 마이그레이션(Pulumi 마이그레이션) 여정에 작은 도움이 되었기를 바랍니다. 다음번에는 Pulumi의 고급 기능이나 특정 클라우드 서비스 연동에 대해 더 깊이 파고들어 보는 시간을 가져볼게요. 혹시 궁금한 점이나 공유하고 싶은 삽질 경험이 있다면 언제든지 댓글로 남겨주세요! 저도 배우는 게 많을 겁니다. 🎉

    Pulumi IaC 및 DevOps 요약 인포그래픽

    Pulumi 로고와 함께 IaC, DevOps, 자동화, 클라우드 관리 등의 핵심 개념을 시각적으로 요약한 인포그래픽입니다.

  • [Cloud] Terraform vs Pulumi: IaC 도구 비교 및 선택 가이드

    IaC 도구 선택, 생각보다 중요한 문제입니다

    인프라를 코드로 관리하기 시작한 게 벌써 7~8년 전 일인데요, 그때만 해도 Terraform(테라폼)이 사실상 IaC(Infrastructure as Code, 인프라를 코드로 관리하는 방식)의 표준처럼 여겨졌습니다. 그런데 최근 몇 년 사이에 Pulumi(풀루미)가 치고 올라오면서 팀 내에서도 “우리 이제 Pulumi로 갈아타야 하는 거 아니야?“라는 얘기가 슬슬 나오기 시작하더라고요.

    저도 처음엔 “또 새로운 도구 나왔네” 하고 넘겼는데, 실제로 홈랩에서 Terraform과 Pulumi를 나란히 써보면서 생각이 좀 바뀌었습니다. 단순히 어느 게 더 낫다는 게 아니라, 팀 상황과 사용 목적에 따라 선택이 완전히 달라지는 도구라는 걸 직접 느꼈거든요.

    이 글에서는 Terraform vs Pulumi를 실제 사용 경험을 바탕으로 비교해드리려고 합니다. IaC 도구 비교 글들이 많긴 한데, 대부분 공식 문서 요약 수준이라 아쉬웠거든요. 실무에서 어떤 차이가 나는지 한번 풀어볼게요.

    ▲ Terraform과 Pulumi — 둘 다 훌륭한 IaC 도구지만, 철학이 다릅니다

    Terraform과 Pulumi, 각각 어떤 도구인가요?

    Terraform — HCL로 선언하는 인프라

    Terraform은 HashiCorp(해시코프)가 만든 오픈소스 IaC 도구입니다. HCL(HashiCorp Configuration Language, 해시코프 설정 언어)이라는 자체 DSL(Domain-Specific Language, 도메인 특화 언어)을 사용하는데요. 쉽게 말해 “이런 인프라가 존재해야 해”라고 선언하면 Terraform이 현재 상태와 비교해서 필요한 작업을 자동으로 처리하는 방식입니다.

    2014년에 처음 나왔으니까 이미 10년이 넘었네요. 덕분에 Provider(프로바이더, 클라우드/서비스 연동 플러그인) 생태계가 정말 풍부합니다. AWS, GCP, Azure는 물론이고 GitHub, Datadog, PagerDuty까지 대부분의 주요 서비스를 지원해요.

    다만 2023년에 HashiCorp가 라이선스를 BSL(Business Source License)로 변경하면서 커뮤니티가 반발했습니다. 이 때문에 OpenTofu(오픈토푸)라는 포크 프로젝트도 생겼어요. 라이선스 정책은 도구 선택 시 꼭 고려해야 할 사항입니다.

    Pulumi — 진짜 프로그래밍 언어로 인프라를

    Pulumi는 2018년에 등장한 IaC 도구인데, Terraform과는 완전히 다른 접근을 취합니다. Python, TypeScript, Go, C#, Java 같은 범용 프로그래밍 언어로 인프라를 정의한다는 게 핵심이에요.

    처음 들었을 땐 “그게 뭐가 좋아?” 싶었는데, 직접 써보니 차이가 꽤 크더라고요. 반복문, 조건문, 함수, 클래스 같은 프로그래밍 언어의 모든 기능을 인프라 코드에 그대로 쓸 수 있거든요. 기존 패키지 생태계(npm, pip 등)도 활용 가능합니다.

    State(상태, 인프라의 현재 상태를 저장하는 파일) 관리는 Pulumi Cloud를 이용하거나, AWS S3나 Azure Blob 같은 스토리지에 직접 저장할 수 있어요.

    핵심 철학 차이: 선언형 vs 명령형

    Terraform과 Pulumi의 가장 근본적인 차이는 선언형(Declarative) vs 명령형(Imperative) 접근 방식입니다. 이 차이가 실제 개발 경험에 큰 영향을 미칩니다.

    항목 Terraform Pulumi
    언어 HCL (자체 DSL) Python, TypeScript, Go, C#, Java 등
    패러다임 선언형 (Declarative) 선언형 + 명령형 혼합
    State 관리 로컬 파일 또는 원격 Backend Pulumi Cloud 또는 자체 Backend
    라이선스 BSL 1.1 (2023년 변경) Apache 2.0
    Provider 생태계 매우 풍부 (수천 개) 풍부 (Terraform Provider 재활용 가능)
    학습 곡선 HCL 문법 별도 학습 필요 기존 언어 지식 활용 가능
    테스트 별도 도구 필요 (Terratest 등) 기존 테스트 프레임워크 활용
    IDE 지원 플러그인 필요 언어별 IDE 지원 그대로

    실제 코드로 보는 Terraform vs Pulumi 차이

    말로만 설명하면 와닿지 않으니까, 같은 작업을 두 도구로 작성한 코드를 비교해볼게요. AWS S3 버킷 3개를 만드는 간단한 예시입니다.

    Terraform 방식 — count와 for_each

    Terraform에서 여러 리소스를 만들려면 count나 for_each를 써야 합니다. 처음엔 문법이 좀 낯설 수 있어요.

    # variables.tf
    variable "bucket_names" {
      type    = list(string)
      default = ["my-app-logs", "my-app-backups", "my-app-temp"]
    }
    
    # main.tf
    resource "aws_s3_bucket" "app_buckets" {
      for_each = toset(var.bucket_names)
      bucket   = each.value
    }
    
    resource "aws_s3_bucket_versioning" "app_buckets" {
      for_each = aws_s3_bucket.app_buckets
      bucket   = each.value.id
    
      versioning_configuration {
        status = "Enabled"
      }
    }

    Pulumi 방식 — 프로그래밍 언어처럼

    Pulumi에서는 Python으로 같은 작업을 이렇게 씁니다. 훨씬 직관적이죠?

    import pulumi
    import pulumi_aws as aws
    
    bucket_names = ["my-app-logs", "my-app-backups", "my-app-temp"]
    
    for bucket_name in bucket_names:
        bucket = aws.s3.Bucket(
            bucket_name,
            bucket=bucket_name
        )
        
        versioning = aws.s3.BucketVersioning(
            f"{bucket_name}-versioning",
            bucket=bucket.id,
            versioning_configuration={
                "status": "Enabled"
            }
        )

    Pulumi 코드가 더 간결하고 읽기 쉽지 않나요? 이게 바로 범용 프로그래밍 언어를 쓰는 장점입니다. 변수, 함수, 클래스 등 익숙한 개념들을 그대로 활용할 수 있거든요.

  • [Cloud] Pulumi vs Terraform: 멀티 클라우드 IaC 선택 가이드 및 실전 활용

    [Cloud] Pulumi vs Terraform: 멀티 클라우드 IaC 선택 가이드 및 실전 활용

    IaC(Infrastructure as Code)는 왜 필요할까요?

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘도 여전히 복잡한 인프라 구성에 머리 싸매고 계신가요? 요즘 같은 멀티 클라우드(Multi-Cloud) 시대에는 온프레미스(On-Premise)와 여러 클라우드 벤더(Cloud Vendor)를 넘나들며 인프라를 관리해야 하는 경우가 흔하죠. 저도 처음엔 수동으로 서버 올리고 네트워크 설정하고… 휴, 생각만 해도 아찔하네요. 사람이 일일이 하다 보니 휴먼 에러(Human Error)는 기본이고, 속도는 느려터지고, 무엇보다 재현성이 없어서 문제였습니다.

    그래서 등장한 개념이 바로 IaC(Infrastructure as Code, 코드형 인프라)예요. 쉽게 말해, 인프라를 코드로 정의하고 관리하는 방식이죠. Git 같은 버전 관리 시스템으로 관리할 수 있고, 자동화는 물론 팀원들과의 협업도 훨씬 수월해집니다. 제가 홈랩에서 이것저것 테스트해볼 때도, IaC 덕분에 환경을 순식간에 구축하고 파괴하면서 실험할 수 있었거든요. 시간 절약이 어마어마해요!

    멀티 클라우드 환경에서 IaC를 사용하는 인프라 프로비저닝 개념 다이어그램

    Terraform vs Pulumi: 핵심 개념 파헤치기

    IaC 도구는 정말 다양합니다만, 현재 시장에서 가장 강력한 양대 산맥을 꼽으라면 단연 Terraform(테라폼)과 Pulumi(풀루미)일 겁니다. 두 도구 모두 클라우드 인프라를 코드로 정의하고 배포할 수 있게 해주지만, 접근 방식에 큰 차이가 있어요. 저도 처음엔 뭐가 뭔지 헷갈려서 한참을 삽질했었죠.

    Terraform (테라폼)

    • 선언적 언어(Declarative Language): Terraform은 HCL(HashiCorp Configuration Language)이라는 자체 언어를 사용해요. "최종 상태가 이렇게 되어야 한다"라고 선언하면, Terraform이 현재 상태와 비교해서 필요한 변경 사항을 알아서 적용해줍니다. 예를 들어, aws_instance 리소스 블록을 정의하면, Terraform이 AWS에 해당 인스턴스를 생성하거나 업데이트하죠.
    • 상태 파일(State File) 관리: Terraform은 배포된 인프라의 현재 상태를 .tfstate 파일에 기록해요. 이 상태 파일을 통해 다음에 어떤 변경 사항을 적용할지 판단하는데, 이 파일 관리가 꽤 중요하고 때론 골치 아울 때도 있어요. S3 같은 원격 스토리지(Remote Storage)에 저장하고 잠금(Locking) 기능을 사용하는 게 일반적이에요.
    • 모듈(Modules): 재사용 가능한 인프라 구성 단위를 모듈로 만들 수 있어서, 복잡한 인프라도 효율적으로 관리할 수 있어요.

    Pulumi (풀루미)

    • 범용 프로그래밍 언어(General-Purpose Programming Language): Pulumi의 가장 큰 특징은 Python, TypeScript, Go, C# 등 여러분이 익숙한 프로그래밍 언어를 그대로 사용한다는 점이에요. 이게 진짜 매력적입니다! 일반 애플리케이션 개발하듯이 인프라 코드를 작성할 수 있어요. 조건문, 반복문, 함수 등 프로그래밍 언어의 모든 기능을 활용할 수 있다는 것이 큰 장점이죠.
    • 상태 관리(State Management): Pulumi도 인프라 상태를 관리하지만, 기본적으로 Pulumi 서비스에서 관리해주거나 S3, Azure Blob Storage 등 다양한 백엔드(Backend)를 지원해요. Terraform처럼 로컬 .tfstate 파일에 얽매이지 않아서 좀 더 유연하더라고요.
    • 테스트 용이성(Testability): 프로그래밍 언어의 장점을 살려 단위 테스트(Unit Test), 통합 테스트(Integration Test) 등을 적용하기가 훨씬 쉬워요. 저도 TypeScript로 Pulumi 코드를 작성하면서 Jest 같은 프레임워크로 테스트를 붙여보니, 안정성이 확 올라가더라고요.

    멀티 클라우드 환경에서 Pulumi와 Terraform 비교 분석

    자, 그럼 두 도구를 멀티 클라우드 관점에서 비교해볼까요? 제가 여러 프로젝트에 적용해보면서 느낀 점들을 솔직하게 말씀드릴게요.

    특징 Terraform Pulumi
    언어 HCL (HashiCorp Configuration Language) Python, TypeScript, Go, C#, Java 등 범용 프로그래밍 언어
    학습 곡선 HCL 학습 필요 (비교적 쉬움) 선택 언어에 익숙하다면 낮음
    추상화 수준 선언적, 모듈 기반 프로그래밍 언어의 강력한 추상화 및 로직 구현 가능
    상태 관리 .tfstate 파일 (로컬/원격), 잠금 기능 필수 Pulumi 서비스 또는 다양한 백엔드 지원, 더 유연함
    멀티 클라우드 지원 각 클라우드 프로바이더(Provider) 플러그인 각 클라우드 SDK 기반 라이브러리 (더 깊은 통합 가능)
    테스트 terraform plan, 외부 도구 활용 프로그래밍 언어의 테스트 프레임워크 활용 용이
    확장성 프로바이더 개발, 프로비저너(Provisioner) 프로그래밍 언어의 모든 기능 활용, SDK 개발
    커뮤니티/생태계 오래되고 매우 활발함, 방대한 자료 빠르게 성장 중, 비교적 최신

    Terraform은 꽤 오랫동안 IaC 시장을 지배해왔기 때문에 커뮤니티 자료나 레퍼런스가 정말 많아요. 저도 처음엔 Terraform으로 시작했고요. 반면 Pulumi는 비교적 최근에 떠오른 도구지만, 프로그래밍 언어의 유연성 때문에 개발자 친화적이라는 평이 많습니다. 특히 복잡한 로직이 필요한 인프라 구성이나 기존 개발 워크플로우(Workflow)와 통합하고 싶을 때 Pulumi가 빛을 발하더라고요.

    실전 활용: 간단한 웹 서버 배포 (Terraform vs Pulumi)

    백문이 불여일견이죠! AWS에 간단한 EC2 인스턴스(Instance)를 배포하는 예제를 통해 두 도구의 차이를 직접 느껴보시죠. 제 홈랩에서도 늘 이렇게 시작하곤 합니다.

    Terraform 예제

    main.tf 파일에 다음과 같이 작성해요.

    # main.tf
    
    provider "aws" {
      region = "ap-northeast-2" # 서울 리전
    }
    
    resource "aws_instance" "web_server" {
      ami           = "ami-0a0c4fdd9d45e4895" # Ubuntu 20.04 LTS (서울 리전 기준)
      instance_type = "t2.micro"
      tags = {
        Name = "MyWebServer-Terraform"
      }
    }
    

    명령어는 간단해요.

    terraform init
    terraform plan
    terraform apply --auto-approve
    

    terraform init으로 프로바이더를 초기화하고, terraform plan으로 어떤 변경 사항이 생길지 미리 확인합니다. 마지막으로 terraform apply로 인프라를 배포하죠. 정말 직관적이에요!

    Pulumi 예제 (TypeScript)

    index.ts 파일에 다음과 같이 작성해요.

    // index.ts
    
    import * as aws from "@pulumi/aws";
    
    const webServer = new aws.ec2.Instance("web-server-pulumi", {
        ami: "ami-0a0c4fdd9d45e4895", // Ubuntu 20.04 LTS (서울 리전 기준)
        instanceType: "t2.micro",
        tags: {
            Name: "MyWebServer-Pulumi",
        },
    });
    
    export const instanceId = webServer.id;
    export const publicIp = webServer.publicIp;
    

    명령어는 다음과 같아요.

    pulumi stack init dev # 스택 초기화 (환경 분리)
    pulumi up --yes # 인프라 배포
    

    Pulumi는 스택(Stack) 개념이 있어서 개발, 스테이징, 프로덕션 환경을 깔끔하게 분리할 수 있어요. pulumi up 명령어로 배포하고, --yes 옵션으로 확인 과정을 생략할 수 있습니다. 프로그래밍 언어의 문법을 그대로 따르기 때문에, 개발자라면 훨씬 친숙하게 느껴지실 거예요.

    Terraform과 Pulumi로 생성된 AWS EC2 인스턴스 목록

    ⚠️ 제가 겪었던 삽질과 트러블슈팅 경험

    13년차 엔지니어도 삽질은 피할 수 없죠! 저도 이 두 도구를 쓰면서 여러 번 멘붕에 빠졌어요. 몇 가지 기억에 남는 삽질 경험과 해결법을 공유할게요.

    Terraform: 상태 파일 관리의 늪

    제일 많이 겪었던 건 상태 파일(State File) 충돌이에요. 팀원 여럿이 동시에 같은 인프라를 건드리다 보면 .tfstate 파일이 꼬이는 경우가 생기더라고요. 특히 협업 툴(Collaboration Tool)이나 CI/CD 파이프라인(Pipeline) 없이 수동으로 작업할 때 심했습니다. 상태 파일이 꼬이면 terraform plan 결과가 이상하게 나오거나, 심지어 실제 인프라와 상태 파일 간의 불일치(Drift)가 발생해서 엉뚱한 리소스가 삭제될 뻔한 적도 있었죠. 😱

    • 해결법: 항상 원격 백엔드(Remote Backend) (예: AWS S3 + DynamoDB Lock)를 사용하고, 상태 잠금(State Locking)을 활성화해야 해요. 그리고 CI/CD 파이프라인을 구축해서 모든 변경 사항은 파이프라인을 통해서만 적용되도록 강제하는 것이 가장 안전합니다.

    Pulumi: 언어 버전 의존성

    Pulumi는 범용 프로그래밍 언어를 사용하다 보니, 언어 버전이나 패키지 의존성(Package Dependency) 문제로 삽질한 적도 있어요. 예를 들어, 특정 Pulumi AWS 라이브러리가 특정 Node.js 버전에서만 제대로 동작한다든지, npm install 과정에서 에러가 나는 경우요. 이게 진짜 별것 아닌 것 같아도, 디버깅(Debugging)하다 보면 시간을 꽤 잡아먹어요. 😅

    • 해결법: package.json(TypeScript/Node.js)이나 requirements.txt(Python)에 정확한 버전 정보를 명시하고, nvm(Node Version Manager)이나 pyenv(Python Version Manager) 같은 도구로 개발 환경을 일관되게 유지하는 것이 중요해요. 그리고 Pulumi 관련 라이브러리들도 최신 버전으로 꾸준히 업데이트해주는 게 좋아요.

    공통: 리프레시 명령어의 함정

    가끔 실제 인프라가 변경되었는데 상태 파일에 반영이 안 되는 불일치가 생기면 terraform refresh나 pulumi refresh 명령어를 사용하게 되죠. 그런데 이 명령어를 너무 맹신하면 안 돼요. 특히 중요한 리소스에 대해서는 리프레시 전에 항상 백업(Backup)을 해두거나, plan 명령어로 예상 변경 사항을 꼼꼼히 확인하는 습관을 들이세요. 예전에 리프레시 한 번 잘못했다가 스테이징 환경이 날아갈 뻔한 아찔한 경험도 있습니다. ⚠️

    그래서, 어떤 IaC 도구를 선택해야 할까요?

    결론부터 말씀드리자면, "정답은 없다"예요! (싱거운가요? ㅎㅎ) 하지만 여러분의 상황에 맞는 최적의 선택은 분명히 있습니다.

    Terraform을 선택해야 하는 경우

    • 인프라 전문 팀/운영 팀이 주도적으로 IaC를 도입할 때: HCL은 인프라 관리에 특화되어 있어 직관적이에요.
    • 방대한 기존 레퍼런스와 안정적인 커뮤니티 지원이 중요할 때: 오래된 만큼 자료가 정말 많습니다.
    • 비교적 단순하고 선언적인 인프라 구성이 많을 때: 복잡한 로직 없이 리소스 정의만으로 충분한 경우요.
    • GitOps(깃옵스) 워크플로우를 강력하게 따르고자 할 때: Terraform Cloud/Enterprise 같은 솔루션과 통합이 잘 되어 있어요.

    Pulumi를 선택해야 하는 경우

    • 개발 팀이 직접 인프라를 관리하거나, 개발 워크플로우에 IaC를 통합하고 싶을 때: 익숙한 프로그래밍 언어로 개발 생산성을 높일 수 있어요.
    • 복잡한 로직이나 조건부 인프라 구성이 필요할 때: 프로그래밍 언어의 모든 기능을 활용하여 동적인 인프라를 만들 수 있습니다.
    • 인프라 코드에 단위 테스트/통합 테스트를 적극적으로 적용하여 안정성을 높이고 싶을 때요.
    • 서버리스(Serverless) 아키텍처나 컨테이너 기반 환경(Containerized Environment)에 더 깊이 통합하고 싶을 때: Lambda 함수나 Kubernetes 리소스를 직접 코드로 제어하기가 편해요.

    Terraform과 Pulumi 선택 가이드 요약 인포그래픽

    마무리하며: 13년차 인프라 엔지니어의 조언

    오늘은 Pulumi(풀루미)와 Terraform(테라폼), 두 가지 강력한 IaC 도구에 대해 깊이 있게 다뤄봤어요. 멀티 클라우드 환경에서 인프라를 효율적으로 관리하고 자동화하는 것은 이제 선택이 아닌 필수가 되었죠. 저도 처음엔 "이걸 언제 다 배우지?" 했었는데, 막상 익숙해지니 정말 편하더라고요. 삽질 끝에 드디어 원하는 대로 인프라가 배포될 때의 그 희열은 경험해본 사람만 알 겁니다! 🎉

    두 도구 모두 강력한 장점을 가지고 있으니, 여러분의 팀 구성원들이 어떤 언어에 더 익숙한지, 어떤 유형의 인프라를 주로 다루는지를 고려해서 현명하게 선택하시길 바랍니다. 추가로 어떤 수준의 추상화와 유연성이 필요한지도 함께 생각하면서요. 가능하다면 작은 프로젝트에 두 가지를 모두 적용해보면서 장단점을 직접 느껴보는 것도 좋은 방법입니다.

    인프라 코드를 작성하는 것은 마치 소프트웨어 개발과 같아요. 지속적으로 리팩토링(Refactoring)하고, 버전 관리를 철저히 하며, 테스트를 통해 안정성을 확보하는 것이 중요해요. 이 글이 여러분의 IaC 여정에 조금이나마 도움이 되었기를 바랍니다. 다음번에는 더 유익한 주제로 찾아올게요. 감사합니다!

    홈랩에서 IaC 코드를 작성하는 13년차 인프라 엔지니어

  • [Cloud] Pulumi vs Terraform 비교: IaC 도구 선택 가이드

    IaC 도구 선택, 왜 이렇게 어렵냐고요 😅

    팀에서 인프라 자동화 도구를 새로 도입하려고 할 때, 가장 먼저 나오는 질문이 있죠. “Terraform 쓸까요, Pulumi 쓸까요?”

    저도 몇 년 전에 이 선택 앞에서 한참 고민했거든요. 당시엔 Terraform이 거의 IaC(Infrastructure as Code, 코드로 인프라를 정의하고 관리하는 방식)의 표준처럼 여겨지던 시절이었는데, Pulumi라는 새로운 녀석이 등장하면서 “이거 써야 하나?” 싶었던 기억이 납니다.

    결론부터 말씀드리면 — 둘 다 써봤고, 둘 다 장단점이 뚜렷해요. Pulumi vs Terraform 비교는 단순히 “어느 게 더 좋냐”의 문제가 아니라, 팀 상황과 프로젝트 성격에 따라 달라지는 문제더라고요. 오늘은 13년 동안 인프라 엔지니어로 일하면서 직접 겪은 경험을 바탕으로, 이 두 IaC 도구를 제대로 비교해드리겠습니다.

    Pulumi와 Terraform의 전체적인 구조와 접근 방식 차이를 보여주는 개요 다이어그램

    Terraform과 Pulumi, 각각 어떤 도구인가요?

    Terraform — IaC의 베테랑

    Terraform은 HashiCorp에서 만든 오픈소스 IaC 도구로, 2014년에 처음 출시됐습니다. HCL(HashiCorp Configuration Language)이라는 자체 DSL(Domain-Specific Language, 특정 목적을 위해 만들어진 언어)을 사용하는 게 특징이에요.

    쉽게 말해서, “인프라를 선언적으로 정의”하는 방식입니다. “EC2 인스턴스 이렇게 만들어줘”라고 적어두면, Terraform이 알아서 현재 상태와 비교해서 필요한 작업만 수행하는 거죠.

    # Terraform 예시 — AWS EC2 인스턴스 생성
    resource "aws_instance" "web_server" {
      ami           = "ami-0c55b159cbfafe1f0"
      instance_type = "t3.micro"
    
      tags = {
        Name        = "web-server"
        Environment = "production"
      }
    }
    
    output "instance_ip" {
      value = aws_instance.web_server.public_ip
    }

    처음 보면 “이게 뭔 언어야?” 싶을 수 있는데, 몇 번 써보면 꽤 직관적이더라고요. 특히 인프라 구성을 “읽는” 관점에서는 진짜 편합니다.

    Pulumi — 개발자 친화적인 도전자

    Pulumi는 2018년에 등장한 비교적 젊은 IaC 도구입니다. 가장 큰 차별점은 실제 프로그래밍 언어를 그대로 사용한다는 점이에요. Python, TypeScript, Go, C#, Java 등을 지원하거든요.

    처음 이걸 봤을 때 “오, 이거 개발자들 좋아하겠다” 싶었어요. 인프라 엔지니어보다 소프트웨어 개발자 출신이 많은 팀이라면 특히요.

    # Pulumi 예시 — Python으로 AWS EC2 인스턴스 생성
    import pulumi
    import pulumi_aws as aws
    
    web_server = aws.ec2.Instance(
        "web-server",
        ami="ami-0c55b159cbfafe1f0",
        instance_type="t3.micro",
        tags={
            "Name": "web-server",
            "Environment": "production",
        }
    )
    
    pulumi.export("instance_ip", web_server.public_ip)

    같은 결과물인데, Python 개발자라면 아래 코드가 훨씬 익숙하게 느껴질 겁니다. 이게 Pulumi의 핵심 가치예요.

    Pulumi vs Terraform 핵심 차이점 비교

    자, 이제 본격적으로 비교해 봅시다. 제가 직접 두 도구를 써보면서 느낀 차이점들을 정리했어요.

    비교 항목 Terraform Pulumi
    언어 HCL (자체 DSL) Python, TypeScript, Go, C# 등
    학습 곡선 HCL은 쉽지만, 복잡한 로직은 어려움 언어는 익숙하지만 Pulumi 개념 학습 필요
    상태 관리 로컬 파일 또는 원격 백엔드 Pulumi Cloud 또는 자체 백엔드
    프로바이더 생태계 매우 방대 (성숙한 생태계) 성장 중 (Terraform 프로바이더 브리지 지원)
    테스트 제한적 (Terratest 등 별도 도구 필요) 언어 기본 테스트 프레임워크 활용 가능
    커뮤니티 매우 활발, 레퍼런스 풍부 성장 중
    라이선스 BSL 1.1 (v1.5.5부터 변경) Apache 2.0 (오픈소스)
    엔터프라이즈 기능 Terraform Cloud/Enterprise Pulumi Cloud

    ⚠️ 라이선스 변경 이슈 주의! Terraform은 2023년 8월에 라이선스를 MPL 2.0에서 BSL(Business Source License) 1.1로 변경했습니다. 이 때문에 OpenTofu라는 포크 프로젝트가 생겼을 정도로 커뮤니티에서 논란이 됐었어요. 상업적 목적으로 사용할 때는 라이선스 조건을 꼭 확인하세요.

    Terraform의 plan/apply 워크플로우와 Pulumi의 preview/up 워크플로우를 나란히 비교한 다이어그램

    실전에서 느끼는 차이 — 직접 써보니까요

    Terraform이 빛나는 순간들

    제가 Terraform을 처음 도입했을 때가 2019년쯤이었는데, 당시 팀에 인프라 엔지니어가 저 포함 3명이었어요. 개발팀과 협업할 일이 많았는데, HCL 파일을 코드 리뷰할 때 개발자들도 꽤 잘 읽더라고요. 선언적 문법이라 “이 리소스가 이렇게 생겼구나”를 직관적으로 파악하기 좋거든요.

    특히 이런 상황에서 Terraform이 강점을 발휘했어요:

    • 💡 팀에 인프라 전문가 비율이 높을 때 — HCL에 익숙해지면 오히려 더 깔끔하게 관리됨
    • 💡 레퍼런스가 중요할 때 — 거의 모든 클라우드 리소스에 대한 예제가 넘쳐남
    • 💡 안정성이 최우선일 때 — 10년 넘은 도구라 예측 가능한 동작이 보장됨
    • 💡 모듈 재사용이 핵심일 때 — Terraform Registry의 공개 모듈 생태계가 압도적
    # Terraform 모듈 활용 예시
    module "vpc" {
      source  = "terraform-aws-modules/vpc/aws"
      version = "~> 5.0"
    
      name = "my-vpc"
      cidr = "10.0.0.0/16"
    
      azs             = ["ap-northeast-2a", "ap-northeast-2b", "ap-northeast-2c"]
      private_subnets = ["10.0.1.0/24", "10.0.2.0/24", "10.0.3.0/24"]
      public_subnets  = ["10.0.101.0/24", "10.0.102.0/24", "10.0.103.0/24"]
    
      enable_nat_gateway = true
    
      tags = {
        Environment = "production"
        Terraform   = "true"
      }
    }

    Terraform Registry에서 검증된 VPC 모듈 몇 줄로 완성이에요. 이런 거 보면 “역시 생태계가 갑이다” 싶죠.

    Terraform의 아픈 부분 😅

    근데 솔직히 말씀드리면, 복잡한 로직 처리할 때는 좀 힘들어요. 예를 들어 “조건에 따라 리소스 개수를 동적으로 결정”하려면…

    # Terraform에서 동적 리소스 생성 — 이게 직관적이지 않음
    resource "aws_security_group_rule" "ingress_rules" {
      count = length(var.ingress_ports)
    
      type              = "ingress"
      from_port         = var.ingress_ports[count.index]
      to_port           = var.ingress_ports[count.index]
      protocol          = "tcp"
      cidr_blocks       = ["0.0.0.0/0"]
      security_group_id = aws_security_group.main.id
    }
    
    # for_each를 쓰면 좀 낫지만, 여전히 복잡한 로직엔 한계가 있음
    resource "aws_instance" "servers" {
      for_each = var.server_configs
    
      ami           = each.value.ami
      instance_type = each.value.instance_type
    
      tags = {
        Name = each.key
      }
    }

    count, for_each 같은 메타 인수를 쓰다 보면 “이게 프로그래밍이 아니라 퍼즐 푸는 느낌”이 들 때가 있어요. 저도 처음엔 이게 뭔가 싶었는데, 익숙해지는 데 시간이 좀 걸렸습니다 ㅎㅎ

    Pulumi가 빛나는 순간들

    반면에 Pulumi는 개발자 팀에서 진가를 발휘하더라고요. 제가 사이드 프로젝트로 홈랩 인프라를 Pulumi(Python)로 관리해봤는데, 이런 점이 진짜 좋았어요:

    # Pulumi Python — 복잡한 로직도 그냥 Python으로
    import pulumi
    import pulumi_aws as aws
    
    # 환경별 설정을 딕셔너리로 관리
    env_configs = {
        "production": {"instance_type": "t3.medium", "count": 3},
        "staging":    {"instance_type": "t3.small",  "count": 1},
        "dev":        {"instance_type": "t3.micro",  "count": 1},
    }
    
    config = pulumi.Config()
    env = config.require("environment")
    current_config = env_configs[env]
    
    # 그냥 for 루프로 인스턴스 생성 — 이게 얼마나 자연스러운지!
    instances = []
    for i in range(current_config["count"]):
        instance = aws.ec2.Instance(
            f"web-server-{i}",
            ami="ami-0c55b159cbfafe1f0",
            instance_type=current_config["instance_type"],
            tags={
                "Name": f"web-server-{i}",
                "Environment": env,
            }
        )
        instances.append(instance)
    
    # 결과 출력도 Python 리스트 컴프리헨션으로
    pulumi.export("instance_ids", [inst.id for inst in instances])

    이거 처음 써봤을 때 “드디어 됐다!” 싶었어요. 프로그래밍 언어의 모든 기능을 그대로 쓸 수 있으니까, 복잡한 조건 처리나 반복 작업이 훨씬 자연스럽거든요.

    Pulumi가 특히 유리한 상황:

    • 💡 팀이 개발자 중심일 때 — TypeScript, Python 등 이미 아는 언어로 바로 시작 가능
    • 💡 인프라 로직이 복잡할 때 — 조건문, 반복문, 함수 등을 자유롭게 사용
    • 💡 테스트 자동화가 중요할 때 — pytest, Jest 등 기존 테스트 도구 그대로 활용
    • 💡 기존 코드베이스와 통합할 때 — 앱 코드와 인프라 코드를 같은 언어로 관리

    Pulumi의 아픈 부분 ⚠️

    근데 Pulumi도 완벽하진 않아요. 제가 겪은 몇 가지 불편한 점들:

    • 레퍼런스 부족 — 문제 생겼을 때 구글링해도 Terraform만큼 자료가 안 나와요. 특히 엣지 케이스는 직접 디버깅해야 하는 경우가 많았음
    • Pulumi Cloud 의존성 — 기본 상태 관리가 Pulumi Cloud를 통하는 방식이라, 자체 관리하려면 별도 설정이 필요
    • 언어별 지원 수준 차이 — TypeScript 지원이 가장 성숙하고, 다른 언어는 업데이트 시점이 조금씩 달라요
    • 팀 온보딩 — 인프라 엔지니어가 특정 프로그래밍 언어에 익숙하지 않으면 오히려 진입 장벽이 될 수 있음

    Pulumi Cloud 콘솔에서 스택 상태와 리소스 배포 결과를 확인하는 화면

    ⚠️ 실전에서 주의해야 할 것들

    Terraform 상태 파일(State File) 관리

    Terraform 쓰면서 가장 많이 삽질하는 부분이 상태 파일 관리예요. 처음에 로컬에 `terraform.tfstate` 파일 두고 팀에서 같이 쓰다가 충돌 났던 경험, 한 번쯤은 다들 있으실 거예요 ㅎㅎ

    # 반드시 원격 백엔드 설정하세요!
    terraform {
      backend "s3" {
        bucket         = "my-terraform-state"
        key            = "production/terraform.tfstate"
        region         = "ap-northeast-2"
        encrypt        = true
        dynamodb_table = "terraform-state-lock"  # 동시 수정 방지용 잠금
      }
    }
    

    DynamoDB로 상태 잠금(State Locking) 설정 안 해두면, 두 사람이 동시에 apply 실행할 때 상태 파일이 꼬일 수 있어요. 이거 한 번 겪어보면 절대 안 잊어버리게 됩니다 😅

    Pulumi 스택(Stack) 분리 전략

    Pulumi에서는 환경별로 스택을 분리하는 게 기본 패턴인데, 초반에 이걸 제대로 설계 안 하면 나중에 꽤 고생해요.

    # Pulumi 스택 생성 및 관리
    pulumi stack init production
    pulumi stack init staging
    pulumi stack init dev
    
    # 현재 스택 확인
    pulumi stack ls
    
    # 스택 전환
    pulumi stack select production
    
    # 배포 미리보기 (Terraform의 plan에 해당)
    pulumi preview
    
    # 실제 배포
    pulumi up

    💡 팁: Pulumi에서 환경별 설정값은 `pulumi config set`으로 관리하세요. 민감한 값은 `–secret` 플래그로 암호화해서 저장할 수 있어요.

    # 일반 설정값
    pulumi config set aws:region ap-northeast-2
    pulumi config set environment production
    
    # 민감한 정보는 암호화 저장
    pulumi config set --secret db_password "super-secret-password"

    Terraform 라이선스 변경 이후 고민

    앞서 언급했지만, 2023년 Terraform의 BSL 라이선스 전환은 꽤 큰 이슈였어요. 이 때문에 OpenTofu라는 오픈소스 포크가 Linux Foundation 산하에서 시작됐고, 많은 조직에서 마이그레이션을 고려하기 시작했죠. Pulumi로 넘어가는 팀들도 일부 있었고요.

    만약 상업적 사용이나 Terraform 기반 서비스 제공을 고려하고 있다면, BSL 1.1 조건을 법무팀과 함께 꼼꼼히 검토하시길 권장합니다.

    결국 뭘 선택해야 할까요? — 상황별 가이드

    제가 컨설팅이나 팀 내 논의에서 자주 받는 질문이 “그래서 뭐 써야 해요?”인데요. 정답은 없지만, 제 기준을 공유해 드릴게요.

    ✅ Terraform을 선택하면 좋은 경우

    • 팀에 인프라 전문가 비율이 높고, HCL에 거부감이 없을 때
    • 커뮤니티 레퍼런스와 안정성이 최우선일 때
    • Terraform Registry의 공개 모듈을 적극 활용하고 싶을 때
    • 기존 Terraform 코드베이스가 있는 팀에 합류할 때
    • 비교적 단순한 인프라 구성이 주를 이룰 때

    ✅ Pulumi를 선택하면 좋은 경우

    • 팀이 소프트웨어 개발자 중심이고, 특정 언어에 능숙할 때
    • 인프라 로직이 복잡해서 프로그래밍적 표현이 필요할 때
    • 인프라 코드에 유닛 테스트를 적용하고 싶을 때
    • 앱 코드와 인프라 코드를 같은 언어로 통합 관리하고 싶을 때
    • 라이선스 이슈에서 자유로운 완전 오픈소스 도구가 필요할 때

    팀 상황과 프로젝트 특성에 따른 Terraform vs Pulumi 선택 가이드 인포그래픽

    자주 묻는 질문 (FAQ)

    Q. Terraform에서 Pulumi로 마이그레이션할 수 있나요?

    네, Pulumi에서 공식적으로 변환 도구를 제공해요. `pulumi convert –from terraform` 명령으로 기본적인 리소스 변환이 가능합니다. 완벽하지는 않지만, 간단한 구성은 꽤 잘 변환되더라고요. 다만 복잡한 모듈이나 커스텀 프로바이더는 수동 작업이 필요할 수 있어요.

    Q. 둘 다 멀티 클라우드(Multi-Cloud)를 지원하나요?

    둘 다 AWS, Azure, GCP 등 주요 클라우드 프로바이더를 지원합니다. Terraform은 프로바이더 생태계가 더 방대하고, Pulumi는 Terraform 프로바이더를 브리지(Bridge)해서 쓸 수 있어서 커버리지 차이가 많이 줄어들었어요.

    Q. Pulumi는 무료인가요?

    Pulumi 자체는 오픈소스(Apache 2.0)로 무료입니다. Pulumi Cloud의 경우 개인 사용은 무료 플랜이 있고, 팀 협업 기능이나 고급 기능은 유료 플랜이 필요해요. 자체 백엔드(S3, Azure Blob Storage 등)를 사용하면 Cloud 없이도 운영 가능합니다.

    Q. 둘 다 Kubernetes(쿠버네티스) 관리에 적합한가요?

    네, 둘 다 Kubernetes 리소스 관리를 지원합니다. 다만 Kubernetes 전용으로는 Helm이나 Kustomize와의 조합이 더 일반적이에요. 클라우드 인프라(EKS 클러스터 생성 등)와 Kubernetes 리소스를 함께 관리할 때 IaC 도구가 유용하게 쓰입니다.

    마무리 — 결국 중요한 건 팀과 컨텍스트

    Pulumi vs Terraform 비교를 오래 해봤지만, 솔직히 말씀드리면 둘 다 훌륭한 IaC 도구입니다. 어느 쪽이 “객관적으로 더 좋다”라고 말하기가 어려워요.

    제 개인적인 포지션을 말씀드리면:

    • 🏢 엔터프라이즈 환경, 인프라 팀 주도 → Terraform (안정성, 레퍼런스, 생태계)
    • 🚀 스타트업, 개발자 팀, 복잡한 로직 → Pulumi (유연성, 언어 친숙도)
    • 🏠 홈랩, 개인 프로젝트 → 둘 다 배워보세요! 경험치 쌓기엔 최고

    저는 요즘 홈랩은 Pulumi(Python)로, 업무 환경은 Terraform으로 관리하고 있어요. 두 도구를 병행하면서 각각의 강점을 더 명확하게 느끼게 됐달까요.

    혹시 이미 둘 중 하나를 쓰고 계신 분들은, 반대편 도구도 간단한 사이드 프로젝트로 한번 써보시길 추천드려요. 비교해봐야 진짜 차이가 느껴지거든요.

    다음 글에서는 Terraform 상태 관리와 원격 백엔드 설정을 더 깊이 다뤄볼 예정이에요. Terraform 쓰다가 상태 파일로 삽질한 경험이 있으신 분들이라면 도움이 될 겁니다. 이전 글에서 다뤘던 클라우드 인프라 자동화 기초도 함께 참고해보세요!

    질문이나 의견은 댓글로 남겨주세요. 저도 아직 배우는 중이라, 여러분의 경험도 궁금합니다 😊