구르미의 개발 이야기

vcpkg cmake gtest를 이용하여 C++ 단위 테스트 환경 구축하기

Gurumee — Tue, 19 Aug 2025 14:55:15 +0900

vcpkg 설치하기

vcpkg란 마이크로소프트에서 만든 C/C++을 위한 패키지 매니저이다.

다음 문서 참조하여 설치한다.

필수 조건

c++
cmake
ninja-build
git

다음 명령어 이용하여 설치한다.

git clone https://github.com/microsoft/vcpkg.git
cd vcpkg && ./bootstrap-vcpkg.sh

환경 변수를 등록한다.

echo "VCPKG_ROOT=$PWD" >> ~/.bashrc
echo "export PATH=\$PATH:$VCPKG_ROOT" >> ~/.bashrc

source ~/.bashrc

다음 명령어를 이용하여 설치를 확인한다.

# vcpkg version
vcpkg version 
# 다음이 출력됨    
vcpkg package management program version 2025-07-21-d4b65a2b83ae6c3526acd1c6f3b51aff2a884533

See LICENSE.txt for license information.

vcpkg, cmake를 이용하여, 프로젝트 만들기

MS 공식 문서에서 관련해서 자세한 내용이 적혀 있다. 먼저 프로젝트 디렉토리를 생성한다.

mkdir hello_vcpkg && cd hello_vcpkg

그 후 vcpkg new 명령어를 이용하여, 메니페스트 파일 vcpkg.json을 생성한다.

vcpkg new --application

그 후 다음 명령어로 fmt 라이브러리를 추가한다.

# vcpkg add port <라이브러리 이름>
vcpkg add port fmt

그럼 vcpkg.json에 다음 내용이 추가된다.

{
  "dependencies": [
    "fmt"
  ]
}

이제 CMakeLists.txt 파일을 다음과 같이 생성한다.

cmake_minimum_required(VERSION 3.10)                 # 프로젝트를 빌드하는 데 필요한 CMake의 최소 버전이 3.10임을 지정
project(hello_vcpkg)                                 # 프로젝트 이름
find_package(fmt CONFIG REQUIRED)                    # fmt 라이브러리가 있는지 확인
add_executable(hello_vcpkg src/main.cpp)             # 소스 파일 src/main.cpp 로부터 hello_vcpkg 실행 파일을 만들게 한다.
target_link_libraries(hello_vcpkg PRIVATE fmt::fmt)  # 실행 파일 hello_vcpkg에 fmt 라이브러리를 링킹합니다.

그 후 src 디렉토리를 만들고 main.cpp 를 생성한 후 다음과 같이 작성한다.

#include <fmt/core.h>
#include "hello.h"

int main() {
    fmt::print("Hello Vcpkg!\n");
    return 0;
}

그 후 루트 디렉토리에 CMakePresets.json을 다음과 같이 작성한다.

{
  "version": 2,
  "configurePresets": [
    {
      "name": "vcpkg",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build",
      "cacheVariables": {
        "CMAKE_TOOLCHAIN_FILE": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake"
      }
    }
  ]
}

그 후 다음 명령어를 입력하여 빌드를 구성한다.

cmake --preset=vcpkg

그 후 다음 명령어로 프로젝트를 빌드할 수 있다.

cmake --build build

애플리케이션 실행은 다음 명령어를 실행하면 된다.

./build/hello_vcpkg

# 다음이 출력됨
Hello Vcpkg!

단위테스트 할 수 있도록 리팩토링하기

테스트를 더 쉽게 하기 위해서 리팩토링을 먼저 진행한다. (보통은 테스트를 작성한 후 리팩토링을 하는 것이 일반적이다.) src 디렉토리 밑에 utils 디렉토리를 만든다. 그 후, hello.h를 다음과 같이 작성한다.

#pragma once
#include <string>

std::string getHelloMessage();

그 후 함수 본문을 작성하기 위해서 hello.cpp를 작성한다.

#include "hello.h"

std::string getHelloMessage() {
    return "Hello Vcpkg!\n";
}

이후 utils 디렉토리에 대해서 cmake 빌드에 들어갈 수 있도록 CMakeLists.txt를 utils 디렉토리 밑에 하나 생성한다.

# utils 라이브러리 생성
# 여기에는 "<라이브러리 이름> <등록할 cpp 파일 1> <등록할 cpp 파일 2> ..." 이렇게 작성한다. 
add_library(utils hello.cpp)              

# utils 디렉토리 하위에 작성된 헤더들을 찾을 수 있게 하는 설정입니다.
target_include_directories(utils PUBLIC  
    ${CMAKE_CURRENT_SOURCE_DIR}
)

그리고 루트 CMakeLists.txt를 다음과 같이 수정한다.

cmake_minimum_required(VERSION 3.10)
project(hello_vcpkg)

set(CMAKE_CXX_STANDARD 17)

# utils 라이브러리 등록
add_subdirectory(src/utils)

find_package(fmt CONFIG REQUIRED)
add_executable(hello_vcpkg src/main.cpp)

# fmt와 함께 utils 라이브러리 등록
target_link_libraries(hello_vcpkg 
    PRIVATE
        fmt::fmt utils
)
target_include_directories(hello_vcpkg 
    PUBLIC
        "${PROJECT_BINARY_DIR}"
        "${PROJECT_SOURCE_DIR}/utils"
)

이제 src/main.cpp를 다음과 같이 수정한다.

#include <fmt/core.h>
#include "hello.h"

int main() {
    auto message = getHelloMessage();
    fmt::print(message);
    return 0;
}

그 다음 빌드하여, 정사 결과가 반환되는지 확인합니다.

# 라이브러리 추가 후 빌드 재구성
cmake --preset=vcpkg       

# 빌드
cmake --build build

# 실행 파일 실행
./build/hello_vcpkg

Google Test 라이브러리를 이용하여 단위 테스트 환경 구축하기

이제 gtest(Google Test) 라이브러리를 이용하여 단위 테스트 환경을 구축할 것이다. 다음 명령어를 입력한다.

vcpkg add port gtest

그럼 vcpkg.json에 다음 내용이 추가된다.

{
  "dependencies": [
    "fmt",
    "gtest" // <- 추가
  ]
}

그 후 tests 디렉토리를 만들고 main_test.cpp를 다음과 같이 작성한다.

#include <gtest/gtest.h>
#include "hello.h"

TEST(MainTest, ReturnsHelloVcpkg) {                 // TEST 매크로는 테스트를 실행하는 함수를 의미한다. 첫 번째 인수는 TestSuitName, 두 번쨰 인수는 TestName이다. 간단하게 말하면, MainTest는 실행할 테스트 클래스, ReturnsHelloVcpkg는 테스트 메소드 이름이다.
    auto message = getHelloMessage();
    EXPECT_EQ(message, "Hello Vcpkg!\n");
}


int main(int argc, char **argv) {                   // gtest 실행 메인 함수이다. 테스트 실행 시, 엔드리포인트가 된다.
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

그 후 CMakeLists.txt에 다음 내용을 추가한다.

cmake_minimum_required(VERSION 3.10)
project(hello_vcpkg)
set(CMAKE_CXX_STANDARD 17)

add_subdirectory(src/utils)

find_package(fmt CONFIG REQUIRED)
add_executable(hello_vcpkg src/main.cpp)
target_link_libraries(hello_vcpkg 
    PRIVATE
        fmt::fmt utils
)
target_include_directories(hello_vcpkg 
    PUBLIC
        "${PROJECT_BINARY_DIR}"
        "${PROJECT_SOURCE_DIR}/utils"
)

# 추가된 내용
enable_testing()
find_package(GTest CONFIG REQUIRED)
add_executable(hello_vcpkg_tests tests/main_test.cpp)
target_link_libraries(hello_vcpkg_tests 
    PRIVATE 
        GTest::gtest GTest::gtest_main fmt::fmt pthread utils
)
target_include_directories(hello_vcpkg_tests
    PUBLIC
        "${PROJECT_BINARY_DIR}"
        "${PROJECT_SOURCE_DIR}/utils"
)

add_test(NAME hello_vcpkg_tests COMMAND hello_vcpkg_tests)

그 후, 다음 명령어를 입력한다.

# 라이브러리 추가 후 빌드 재구성
cmake --preset=vcpkg       

# 빌드
cmake --build build

이후 다음 명령어를 입력하면 테스트 파일을 실행할 수 있다.

cd build && ctest && cd ../
# 다음이 출력됨
Test project /home/gurumee/Workspaces/studies/00_project/cli-cpp/01/hello_vcpkg/build
    Start 1: hello_vcpkg_tests
1/1 Test #1: hello_vcpkg_tests ................   Passed    0.00 sec

100% tests passed, 0 tests failed out of 1

Total Test time (real) =   0.01 sec

C# 시작하기

Gurumee — Tue, 15 Apr 2025 22:59:35 +0900

이 문서는 The Rust Programming Language를 보고, C# 기준으로 재구성하였습니다.

C# 설치하기

C# 을 설치하기 위해서 dotnet CLI 도구를 설치합니다. dotnet 도구는 빌드 도구이자, 패키지 매니저이며 C# 개발을 위한 필수적인 도구입니다.

리눅스 환경에 설치하기

이 문서에서는 kali-linux 배포판 기준으로 진행합니다. 다음 명령어를 입력하여 설치합니다.

$ sudo apt-get update && \
  sudo apt-get install -y dotnet-sdk-9.0

⚠️ 이 단계에서 설치가 진행되지 않을 수 있습니다.
현재 운영체제가 기본적으로 dotnet-sdk-9.0 패키지 레포지토리를 인식하지 못할 수 도 있습니다.
$ wget https://packages.microsoft.com/config/debian/12/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
$ sudo dpkg -i packages-microsoft-prod.deb
$ rm packages-microsoft-prod.deb

설치가 완료된 후, dotnet --version 명령어를 입력하면 현재 버전을 확인할 수 있습니다.

$ dotnet --version
9.0.203

업데이트 및 설치

다음 명령어들로 donet 도구를 업데이트 및 삭제할 수 있습니다.

업데이트:

$ sudo apt-get update
$ sudo apt-get upgraade

삭제:

$ sudo apt-get remove --purge dotnet-sdk-9.0

Hello World!

적절한 코드 에디터 혹은 IDE를 설치하세요!

이 절을 진행하기 이전에, 러스트 개발하기 좋은 코드 에디터 혹은 IDE를 설치해주세요. 대표적인 코드 에디터로는 VSCode, Cursor AI , Wind Surf 가 있고, IDE로는 Visual Studio, Rider 가 있습니다. 이 문서에서는 코드 에디터 Cursor AI 기준으로 합니다.

Hello World!란 프로그래밍 언어를 배울 때, 관례적으로 만드는, 단순히 Hello World!라는 문자열을 출력하는 프로그램입니다.

프로젝트 생성하기

먼저 dotnet new 명령어를 이용하여 프로젝트를 생성하세요!

# 프로젝트 모음 디렉토리 생성
$ mkdir ~/projects

# 프로젝트 모음 디렉토리로 이동
$ cd ~/projects

# 콘솔 기반 Hello World! 프로젝트 생성
$ dotnet new console --use-program-main -o HelloWorld
The template "Console App" was created successfully.

Processing post-creation actions...
Restoring /home/gurumee/Workspaces/studies/TheCSharapProgrammingLanguage/HelloWorld/HelloWorld.csproj:
Restore succeeded.

# Hello World! 프로젝트 이동
$ cd HelloWorld

이제 생성된 프로젝트가 어떻게 구성되었는지 확인해보겠습니다.

# 디렉토리 구성 확인
$ tree              
.
├── HelloWorld.csproj
├── obj
│   ├── HelloWorld.csproj.nuget.dgspec.json
│   ├── HelloWorld.csproj.nuget.g.props
│   ├── HelloWorld.csproj.nuget.g.targets
│   ├── project.assets.json
│   └── project.nuget.cache
└── Program.cs

2 directories, 7 files

여기서 중요한 파일 몇 가지만 짚고 넘어가겠습니다.

HelloWorld.csproj : 프로젝트 설정 파일입니다. 현재 C# 버전 정보 등의 프로젝트 설정들이 들어있습니다.
Program.cs : 메인 함수가 존재하고 있는 C# 파일입니다. .cs 확장자는 C# 으로 작성된 코드 파일을 의미합니다.

이제 생성된 Program.cs 코드를 확인해봅시다.

namespace HelloWorld;

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
}

Hello World! 프로그램 뜯어보기

Program.cs 코드를 분석해봅시다. 먼저 살펴볼 부분은 다음과 같습니다.

namespace HelloWorld;

이 부분은 C# 에서 네임스페이스를 지정한 부분입니다. C# 에서 네임스페이스는 고유한 공간을 의미하며, 대규모 프로젝트에서 클래스 및 메서드 이름의 범위를 제어하는 단위입니다.

그 다음은 클래스입니다.

// ...
class Program
{
    // ...
}

C# 의 모든 것은 클래스로 이루어져 있습니다. 클래스는 개체의 속성을 나타내는 필드들과 행동을 정의하는 메소드들을 가질 수 있습니다. 여기서는 Main 메소드를 정의하기 위해서 꼭 필요한 구문이다 정도로 이해하고 넘어가도 좋습니다.

이제 Main 메소드입니다.

// ... 
    static void Main(string[] args)
    {
        Console.WriteLine("Hello, World!");
    }
 }

여기서 중요한 부분 몇 가지만 짚고 넘어가겠습니다. 먼저, Main 메소드는 프로그램의 시작 지점입니다. 아주 특별한 메소드로써, 프로젝트 내에서 단 하나의 클래스에서만 유일하게 존재할 수 있습니다. 메소드는 일종의 작은 코드 조각으로써, 구문들로 구성되어 있다고 합니다. Main 메소드는 Hello, World! 문자열을 출력합니다.

Console.WriteLine 은 콘솔 객체의 메소드로 주어진 문자열을 출력하는 메소드입니다. 메소드 이름 뒤에는 () 를 꼭 써야 합니다. 이 안에는 인자를 전달합니다. 이 메소드의 인자로 "Hello, World!" 문자열이 전달되었습니다.

Main 메소드의 인자 string[] args 는 특별한 인자입니다. 프로그램 실행 인자로써 외부에서 데이터를 전달 받을 때 사용합니다. 지금은 그냥 이런 것이 있다 정도로만 이해해주시면 됩니다.

마지막으로 구문 뒤에는 반드시 ; 이 붙습니다.

C# 프로젝트 실행하기

이제 프로젝트를 실행해보도록 하겠습니다. 터미널에 dotnet run 이란 명령어를 입력하면 프로젝트를 실행할 수 있습니다.

# 프로젝트 실행
$ dotnet run          
Hello, World!

C# 프로젝트 빌드하기

이제 마지막으로 프로젝트를 빌드하고 실행해보겠습니다. 터미널에 dotnet build 명령어를 입력하면 프로젝트를 빌드할 수 있습니다.

$ dotnet build
Restore complete (0.3s)
  HelloWorld succeeded (0.1s) → bin/Debug/net9.0/HelloWorld.dll

Build succeeded in 0.6s

기본적으로 빌드하면, bin/Debug/net9.0 폴더에 HelloWorld 란 실행 파일이 생성됩니다. 이제 실행 파일을 생성해봅시다.

$ ./bin/Debug/net9.0/HelloWorld
Hello, World!

결국 dotnet run 이란 명령어는 빌드 후 실행 파일을 실행하는 것을 축약한 명령어입니다.

러스트 시작하기

Gurumee — Sat, 12 Apr 2025 21:23:15 +0900

이 문서는 The Rust Programming Language를 보고 재구성하였습니다.

러스트 설치하기

러스트를 설치하기 위해서 rustup CLI 도구를 설치합니다. rustup 도구는 러스트 컴파일러인 rustc , 파일을 깔끔하게 코드 스타일을 관리할 수 있는 포매터 rustfmt, 그리고 라이브러리 의존성을 관리할 수 있는 cargo 등의 도구들이 모두 들어있기 때문에 간편하게 러스트 개발 환경을 구성할 수 있습니다.

리눅스 및 맥 환경에 설치하기

다음 명령어를 입력하여 설치합니다.

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

설치가 완료되면 다음 문구가 나타납니다.

Rust is installed now. Great!

⚠️ 이 단계에서 C 컴파일러 설치가 필요할 수 있습니다!
러스트 링커의 경우, 기본으로 설치됩니다. 그러나, 컴파일 시 실행할 수 없다는 에러가 나타날 수 있습니다. 이 경우에, 각 운영 환경에 맞는 C 컴파일러가 필요합니다.

리눅스:
일반적으로 `gcc` 나 `Clang` 이 설치되어 있습니다. 만약 설치되지 않은 경우 우분투의 `build-essential` 같은 기본 패키지를 재설치하면 컴파일러를 설치할 수 있습니다.

맥:
다음 명령어로 설치할 수 있습니다.
$ xcode-select --install

업데이트 및 설치

다음 명령어들로 rustup 을 업데이트 및 삭제할 수 있습니다.

업데이트:

$ rustup update

삭제:

$ rustup self uninstall

Hello World!

적절한 코드 에디터 혹은 IDE를 설치하세요!
이 절을 진행하기 이전에, 러스트 개발하기 좋은 코드 에디터 혹은 IDE를 설치해주세요. 대표적인 코드 에디터로는 `VSCode`, `Cursor AI` , `Wind Surf` 가 있고, IDE로는 `RustRover` 가 있습니다.

Hello World!란 프로그래밍 언어를 배울 때, 관례적으로 만드는, 단순히 Hello World!라는 문자열을 출력하는 프로그램입니다.

프로젝트 디렉토리 생성하기

먼저 다음 명령어를 이용하여 프로젝트를 생성하세요!

# 프로젝트 모음 디렉토리 생성
$ mkdir ~/projects

# 프로젝트 모음 디렉토리로 이동
$ cd ~/projects

# Hello World! 프로젝트 생성
$ mkdir hello_world

# Hello World! 프로젝트 이동
$ cd hello_world

러스트 프로그램 작성하고 실행하기

이제 main.rs 를 다음과 같이 작성합니다.

fn main() {
    println!("Hello, World!");
}

그 후, 터미널에 다음을 입력하여, “컴파일”합니다.

$ rustc main.rs

그럼 프로젝트 디렉토리 내에 main 이라는 실행 파일이 생성됩니다.

$ ls
main    main.rs

다음과 같이 우리가 생성한 프로그램을 실행할 수 있습니다.

$ ./main
Hello, World!

러스트 프로그램 뜯어보기

먼저 살펴볼 부분은 다음과 같습니다.

fn main() {
    // ...
}

이 부분은 러스트에서 main 함수를 정의한 것입니다. 일반적으로 main 함수는 특별한 함수로써 실행 프로그램에서 가장 먼저 실행되는 부분입니다. 여기서는 프로그램 실행 매개 변수를 아무것도 받지 않았지만, 매개 변수를 받고 싶다면 () 이 부분에 매개 변수를 작성해야 합니다.

러스트에서 함수 본문은 항상 {} 로 감싸주어야 합니다. 이제 main 함수 내 코드를 살펴봅시다.

    println!("Hello, World!");

위 코드가 실제 로직인 Hello, World! 를 출력하는 코드입니다. 대표적으로 세가지만 살펴봅시다.

먼저 println! 은 매크로입니다. 여기서는 호출 부에 ! 가 붙은 건 매크로라고 알아둡시다. 이 매크로는 () 안의 문자열을 출력합니다.

두 번째는, "Hello, World!" 는 문자열 리터럴입니다. 리터럴이란 일반적으로 고정된 값을 의미합니다. 숫자나 문자(’’), 문자열(””)이 대표적인 리터럴입니다.

마지막으로 러스트는 모든 표현식 뒤에 ; 붙여야 합니다. 러스트 코드의 거의 모든 라인이 이 문자로 끝난다는 것을 알아두세요.

Hello Cargo!

이번에는 cargo 를 이용하여 러스트 애플리케이션을 만들어보겠습니다. cargo 란 러스트의 빌드 도구이자 패키지 매니저입니다. 간단한 프로그램이라면, “Hello World!” 프로젝트처럼 간단하게 러스트 코드를 작성하고 rustc 로 컴파일 후 실행해도 좋습니다. 하지만 애플리케이션이 복잡해질수록 cargo 를 이용하는 것을 권장드립니다. 이 도구는 코드 빌드나, 코드 작성에 필요한 외부 라이브러리를 다운로드할 때나, 라이브러리를 제작할 때 겪는 귀찮은 일들을 상당수 줄여주는 편리한 도구입니다

카고로 프로젝트 생성하기

먼저 프로젝트 모음ㅁ 디렉토리로 이동합니다.

# 프로젝트 모음 디렉토리로 이동
$ cd ~/projects

프로젝트 모음 디렉토리에서 현재 생성된 프로젝트 목록을 확인해보겠습니다.

# 프로젝트 목록 확인
$ ls 
hello_world

이제 cargo 로 프로젝트를 생성해봅시다. 다음 명령어를 입력해주세요.

# cargo로 프로젝트 생성
# cargo new <프로젝트 이름>
$ cargo new hello_cargo

다시 프로젝트 목록을 확인해봅시다.

# 프로젝트 목록 확인
$ ls 
hello_cargo  hello_world

hello_cargo 프로젝트가 생성된 것을 확인할 수 있습니다. 이제 디렉토리로 이동한 후 어떻게 디렉토리가 구성되었는지 확인해보겠습니다.

# hello_cargo 프로젝트 이동
$ cd hello_cargo

# 디렉토리 구성 확인
$ tree              
.
├── hello_cargo
│   ├── Cargo.toml
│   └── src
│       └── main.rs
└── hello_world
    └── main.rs

4 directories, 3 files

이제 생성된 src/main.rs 코드를 확인해봅시다.

fn main() {
    println!("Hello, world!");
}

Hello World! 프로젝트와 거의 동일한 코드가 생성된 것을 확인할 수 있습니다.

카고로 애플리케이션 실행하기

이제 애플리케이션을 실행해보도록 하겠습니다. 터미널에 cargo run 이란 명령어를 실행해봅시다.

# 프로젝트 실행
$ cargo run     
   Compiling hello_cargo v0.1.0 (/home/gurumee/Workspaces/studies/the-rust-programming-language/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/hello_cargo`
Hello, world!

다시 src/main.rs 에서 다음처럼 수정해보겠습니다.

fn main() {
    println!("Hello, Cargo!");
}

그 후 다시 cargo run 명령어로 애플리케이션을 실행해봅시다.

# 프로젝트 실행
$ cargo run
   Compiling hello_cargo v0.1.0 (/home/gurumee/Workspaces/studies/the-rust-programming-language/hello_cargo)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.18s
     Running `target/debug/hello_cargo`
Hello, Cargo!

카고로 애플리케이션 빌드하기

이제 마지막으로 애플리케이션을 빌드하고 실행해보겠습니다. 터미널에 cargo build 명령어를 실행해봅시다.

$ cargo build
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.00s

기본적으로 빌드하면, 개발 환경으로 빌드가 실행됩니다. 빌드 후, target/debug 폴더에 hello_cargo 란 실행 파일이 생성됩니다. 이제 실행 파일을 생성해봅시다.

$ ./target/debug/hello_cargo
Hello, Cargo!

결국 cargo run 이란 명령어는 빌드 후 실행 파일을 실행하는 것을 축약한 명령어입니다. 실제 프로덕션 환경에 배포할 애플리케이션을 빌드하려면 터미널에 다음과 같이 명령어를 입력하면 됩니다.

$ cargo build --release
   Compiling hello_cargo v0.1.0 (/home/gurumee/Workspaces/studies/the-rust-programming-language/hello_cargo)
    Finished `release` profile [optimized] target(s) in 0.15s

그럼 마찬가지로 target/release 폴더에 실행 파일이 생성됩니다.

[R] Mac 환경에서 R과 R Studio 설치하기

Gurumee — Sat, 15 Apr 2023 21:41:54 +0900

개요

이 문서는 Mac 환경에서 R과 R Studio를 설치하는 내용을 정리한 문서입니다.

저의 환경은 아래와 같습니다.

Mac OS Ventura 13.1 (intel)
HomeBrew 4.0.13

이 문서는 Mac의 패키지 매니저인 HomeBrew를 통해서 설치를 진행합니다. 만약, HomeBrew를 설치하지 않았다면 다음 문서를 참고해주세요.

주니어 엔지니어의 개발 환경 구축하기 (1) 기본 소프트웨어

개요 이 문서는 필자의 맥북에 개발 환경, 특히 개발 시 필요한 소프트웨어 혹은 기본 소프트웨어를 대체하여 유틸리티를 높이는 소프트웨어들을 설치하는 방법에 대해 다룬다. 이 문서에서 다

gurumee92.tistory.com

설치 R

R프로그래밍 언어를 설치합니다. 터미널에 다음 명령어를 입력해주세요.

$ brew install --cask r
==> Downloading https://cloud.r-project.org/bin/macosx/base/R-4.2.3.pkg
######################################################################## 100.0%
==> Installing Cask r
==> Running installer for r; your password may be necessary.
Package installers may write to any location; options such as `--appdir` are ignored.
Password:
installer: Package name is R 4.2.3 for macOS
installer: Installing at base path /
installer: The install was successful.
   r was successfully installed!

설치가 정상적으로 완료되었다면, 터미널에 다음을 입력해봅니다.

$ R  # R 입력 후 엔터를 입력합니다. 아래부터는 입력 후 출력되는 문구입니다.

R version 4.2.3 (2023-03-15) -- "Shortstop Beagle"
Copyright (C) 2023 The R Foundation for Statistical Computing
Platform: x86_64-apple-darwin17.0 (64-bit)

R은 자유 소프트웨어이며, 어떠한 형태의 보증없이 배포됩니다.
또한, 일정한 조건하에서 이것을 재배포 할 수 있습니다.
배포와 관련된 상세한 내용은 'license()' 또는 'licence()'을 통하여 확인할 수 있습니다.

R은 많은 기여자들이 참여하는 공동프로젝트입니다.
'contributors()'라고 입력하시면 이에 대한 더 많은 정보를 확인하실 수 있습니다.
그리고, R 또는 R 패키지들을 출판물에 인용하는 방법에 대해서는 'citation()'을 통해 확인하시길 부탁드립니다.

'demo()'를 입력하신다면 몇가지 데모를 보실 수 있으며, 'help()'를 입력하시면 온라인 도움말을 이용하실 수 있습니다.
또한, 'help.start()'의 입력을 통하여 HTML 브라우저에 의한 도움말을 사용하실수 있습니다
R의 종료를 원하시면 'q()'을 입력해주세요.

[이전에 저장한 작업공간을 복구하였습니다]

>

이제 1 + 1 을 입력해봅시다.

> 1 + 1   # 1 + 1 입력 후 엔터를 입력합니다.
[1] 2     # 결과가 나옵니다. 2
>

이제 R을 종료합니다. "q()"를 입력합니다.

> q()                             # q() 입력 후 엔터를 칩니다.
Save workspace image? [y/n/c]: y  # y를 입력합니다.
$

설치 R Studio

이제 R 프로그래밍 언어의 전용 IDE인 R Studio를 설치합니다. 터미널에 다음을 입력합니다.

$ brew install --cask rstudio 
==> Caveats
rstudio depends on R. The R Project provides official binaries:

  brew install --cask r

Alternatively, the Homebrew-compiled version of R omits the GUI app:

  brew install r

==> Downloading https://download1.rstudio.org/electron/macos/RStudio-2023.03.0-386.dmg
######################################################################## 100.0%
==> Installing Cask rstudio
==> Moving App 'RStudio.app' to '/Applications/RStudio.app'
   rstudio was successfully installed!

설치가 완료되었다면, R Studio를 실행시켜봅시다. (Finder로 R Studio를 검색하면 됩니다.) 프로그램이 실행되고 다음 화면이 보인다면 성공입니다.

Jaeger 설치하기

Gurumee — Sun, 19 Feb 2023 20:49:36 +0900

이 문서는 분산 추적 시스템 중 하나인 jaeger를 설치하는 것을 다루고 있습니다. 특히, 하나의 바이너리 파일의 실행으로 간단하게 분산 추적 시스템을 구축할 수 있는 all-in-one 모드로 실행하는 것을 목표로 합니다.

준비 사항

이 문서는 Docker 환경에서 Jaeger를 설치합니다. 따라서, Docker가 필요합니다.

Docker v20.10.12 이상
docker-compose v1.29.2 이상

Jaeger 설치

다음 명령어로, Jaeger를 설치할 수 있습니다.

$ docker run -d --name jaeger \
  -e COLLECTOR_ZIPKIN_HOST_PORT=:9411 \
  -e COLLECTOR_OTLP_ENABLED=true \
  -p 6831:6831/udp \
  -p 6832:6832/udp \
  -p 5778:5778 \
  -p 16686:16686 \
  -p 4317:4317 \
  -p 4318:4318 \
  -p 14250:14250 \
  -p 14268:14268 \
  -p 14269:14269 \
  -p 9411:9411 \
  jaegertracing/all-in-one:1.42

만약 docker-compose를 이용하여 구성한다면, 다음과 같이 구성할 수 있습니다.

src/ch02/docker-compose.yml

version: "3.9"
services:
  jaeger: 
    image: "jaegertracing/all-in-one:1.42"
    environment:
      - COLLECTOR_ZIPKIN_HOST_PORT=:9411
      - COLLECTOR_OTLP_ENABLED=true
    ports:
      - "6831:6831/udp"
      - "6832:6832/udp"
      - "5778:5778"
      - "16686:16686"
      - "4317:4317"
      - "4318:4318"
      - "14250:14250"
      - "14268:14268"
      - "14269:14269"
      - "9411:9411"
    networks:
      - getting-started-distributed-tracing

networks:
  getting-started-distributed-tracing:
    driver: bridge

docker-compose를 이용한다면 다음 명령어로 실행이 가능합니다.

$ docker compose up
[+] Running 1/1
 ⠿ Container ch02-jaeger-1  Recreated                                                                                              0.1s
Attaching to ch02-jaeger-1
ch02-jaeger-1  | 2023/02/19 12:11:01 maxprocs: Leaving GOMAXPROCS=6: CPU quota undefined
ch02-jaeger-1  | {"level":"info","ts":1676808661.6135793,"caller":"flags/service.go:119","msg":"Mounting metrics handler on admin server","route":"/metrics"}
# ...
ch02-jaeger-1  | {"level":"info","ts":1676808662.6579118,"caller":"channelz/funcs.go:340","msg":"[core][Channel #10] Channel Connectivity change to IDLE","system":"grpc","grpc_log":true}

정상적으로 실행이 되면, 브라우저에서 다음 URL을 접속해봅니다.

http://localhost:16686

다음 화면이 보이면 성공입니다.

각 포트의 의미

각 포트의 의미는 다음과 같습니다.

port	protocol	component	function
6831	UDP	agent	대부분의 SDK에서 Jaeger로 트레이싱 정보를 전달하는 포트입니다.
6832	UDP	agent	Node.js SDK에서 Jaeger로 트레이싱 정보를 전달하는 포트입니다.
5778	HTTP	agent	샘플링 등의 설정을 확인할 수 있습니다.
16686	HTTP	query	프론트엔드 서비스를 확인할 수 있습니다.
4317	HTTP	collector	COLLECTOR_OTLB_ENABLED가 활성화되어 있다면, gRPC 기반의 OTLP(오픈 텔레메트리 프로토콜)을 수신합니다.
4318	HTTP	collector	COLLECTOR_OTLB_ENABLED가 활성화되어 있다면, http 기반의 OTLP(오픈 텔레메트리 프로토콜)을 수신합니다.
14268	HTTP	collector	클라이언트로부터 직접 트레이스 정보를 수신합니다.
14250	HTTP	collector	model.proto 를 수신합니다.
9411	HTTP	collector	Zipkin호환 엔드포인트입니다.

여러 컴포넌트가 있지만, 이 문서에서는 따로 설명하지 않습니다. (기회가 있다면, 추후 이어지는 장에서 설명하도록 하겠습니다.)

참고

Jaeger 공식 문서 - Getting Started

ArgoCD 맛보기

Gurumee — Wed, 7 Sep 2022 19:30:57 +0900

이 문서에서는 Gitops 구현체 중 하나인 ArgoCD에 대해서 간단히 알아보도록 하곘습니다. 또한 minikube 쿠버네티스 클러스터 환경에서 ArgoCD 배포 후, argocd CLI를 통해 간단히 애플리케이션을 배포하는 내용을 실습해보도록 하겠습니다.

Gitops와 ArgoCD

Gitops란 애플리케이션의 배포와 운영에 관련된 모든 요소를 코드화하여 깃(Git)에서 관리(Ops)하는 방법론 중 하나입니다. CI/CD 중 지속적인 배포(Continuous Deployment)에 초첨을 두고 있으며, 기본 개념은 코드를 이용하여 인프라를 프로비저닝 하고 관리하는 IaC(Infrastructure as Code)에서 나온 것으로 깃옵스는 이를 인프라에서 전체 애플리케이션 범위로 확장하였다고 보시면 됩니다.

Gitops의 장점은 다음과 같습니다.

인프라를 포함한 애플리케이션 배포와 운영에 관련된 모든 것을 코드로 관리할 수 있습니다.
Git을 단일 진실 공급원으로 지정하고 오직 이 곳에서만 관리하도록 합니다. 모든 운영 활동의 시작은 깃이므로 사람 혹은 시스템 간의 혼선을 최소화 할 수 있습니다.
Git 에서 누릴 수 있었던 깃의 기능을 운영 단계에서도 활용할 수 있습니다.(History, Commit, Merge Request/ Review, Revert 등)

ArgoCD는 Gitops의 대표적인 구현체이며, Jenkins 같은 push 방식이 아닌 pull 방식을 채택한 Gitops 도구입니다. 다음은 ArgoCD의 아키텍처를 나타낸 그림입니다.

기본적으로 쿠버네티스 클러스터 내 리소스들로 구성되며, 코드에 반영되면 설치된 ArgoCD가 쿠버네티스 클러스터에 설치된 리소스와 형상을 비교한 뒤, 차이가 있으면 이를 최신 코드 기준으로 동일하게 맞춰줍니다.

자, 이제 간단하게 알아보았으니 ArgoCD를 통해서 애플리케이션을 배포해보는 간단한 실습을 진행해보겠습니다.

요구사항

실습을 진행하기 위해서는 아래 소프트웨어들이 구성되어 있어야 합니다.

docker v20.10.17
minikube v1.24.0
kubectl v1.24.2

쿠버네티스 클러스터에 ArgoCD 배포하기

이전 절에서 언급했듯이 ArgoCD는 쿠버네티스 리소스로 구성되어 있습니다. 따라서 메니페스트를 구성해야 하는데, 여기서는 간단하게 CLI 명령어로 구성해보도록 하곘습니다. 아래 명령어들을 입력합니다.

# argocd 네임스페이스 생성
$ kubectl create namespace argocd

# 쿠버네티스 클러스터에 argocd 설치
$ kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

위 명령어를 실행하면 "argocd" 네임스페이스 아래 다음 리소스들이 구성됩니다.

$ kubectl get all -n argocd
NAME                                                    READY   STATUS    RESTARTS   AGE
pod/argocd-application-controller-0                     1/1     Running   0          115m
pod/argocd-applicationset-controller-78b8b554f9-pg6tv   1/1     Running   0          115m
pod/argocd-dex-server-6bbc85c688-fxqwf                  1/1     Running   0          115m
pod/argocd-notifications-controller-75847756c5-v9qc7    1/1     Running   0          115m
pod/argocd-redis-f4cdbff57-879q5                        1/1     Running   0          115m
pod/argocd-repo-server-d5c7f7ffb-fddm7                  1/1     Running   0          115m
pod/argocd-server-76497676b-m9gq4                       1/1     Running   0          115m

NAME                                              TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)                      AGE
service/argocd-applicationset-controller          ClusterIP   10.111.172.181   <none>        7000/TCP,8080/TCP            115m
service/argocd-dex-server                         ClusterIP   10.100.226.17    <none>        5556/TCP,5557/TCP,5558/TCP   115m
service/argocd-metrics                            ClusterIP   10.109.114.206   <none>        8082/TCP                     115m
service/argocd-notifications-controller-metrics   ClusterIP   10.104.167.93    <none>        9001/TCP                     115m
service/argocd-redis                              ClusterIP   10.102.69.51     <none>        6379/TCP                     115m
service/argocd-repo-server                        ClusterIP   10.104.11.4      <none>        8081/TCP,8084/TCP            115m
service/argocd-server                             ClusterIP   10.109.178.58    <none>        80/TCP,443/TCP               115m
service/argocd-server-metrics                     ClusterIP   10.110.59.129    <none>        8083/TCP                     115m

NAME                                               READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/argocd-applicationset-controller   1/1     1            1           115m
deployment.apps/argocd-dex-server                  1/1     1            1           115m
deployment.apps/argocd-notifications-controller    1/1     1            1           115m
deployment.apps/argocd-redis                       1/1     1            1           115m
deployment.apps/argocd-repo-server                 1/1     1            1           115m
deployment.apps/argocd-server                      1/1     1            1           115m

NAME                                                          DESIRED   CURRENT   READY   AGE
replicaset.apps/argocd-applicationset-controller-78b8b554f9   1         1         1       115m
replicaset.apps/argocd-dex-server-6bbc85c688                  1         1         1       115m
replicaset.apps/argocd-notifications-controller-75847756c5    1         1         1       115m
replicaset.apps/argocd-redis-f4cdbff57                        1         1         1       115m
replicaset.apps/argocd-repo-server-d5c7f7ffb                  1         1         1       115m
replicaset.apps/argocd-server-76497676b                       1         1         1       115m

NAME                                             READY   AGE
statefulset.apps/argocd-application-controller   1/1     115m

구성된 ArgoCD는 웹 UI(이하 "ArgoCD UI")를 제공합니다. 이를 브라우저로 접근하기 위해서는 다음의 4가지 방식이 있습니다.

서비스 타입을 LoadBalancer로 변경
서비스 타입을 NodePort로 변경
Ingress 생성 및 서비스 연결
Port Forward로 서비스 연결

여기서는 가장 간단한 Port Forward 방식을 이용해보도록 하곘습니다. 터미널에 다음을 입력하세요.

$ kubectl port-forward svc/argocd-server -n argocd 8080:443

이제 http://localhost:8080으로 접속하면 ArgoCD UI를 접속할 수 있습니다.

이제 로그인을 해야 하는데, 이 방식으로 설치하게 되면 기본적으로 "admin" 계정과 함께 임의의 비밀번호가 생성됩니다. 비밀번호는 다음 명령어로 확인할 수 있습니다.

# 비밀번호를 확인화기 위한 명령어
$ kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo
# 생성된 비밀번호
7FHwxAybf9aXICII

위에서 생성된 비밀번호와 함께 "admin" 계정으로 로그인하면 다음 화면을 확인할 수 있습니다.

애플리케이션 배포하기

ArgoCD에 애플리케이션을 배포하기 위해서는 몇 가지 설정이 추가적으로 더 필요합니다. 손 쉽게 구성하기 위해서 argocd CLI를 설치한다. mac 환경이라면, 다음 명령어로 손귑게 설치할 수 있습니다.

$ brew install argocd

먼저 argocd CLI로 배포한 ArgoCD에 로그인을 진행해야 합니다. 터미널에 다음을 입력합니다.

# argocd login <ArgoCD URL>
$ argocd login localhost:8080
WARNING: server certificate had error: x509: “Argo CD” certificate is not trusted. Proceed insecurely (y/n)? y  # <- y 입력
Username: admin # <- admin 입력
Password:       # <- 위에서 확인한 비밀번호 입력
'admin:login' logged in successfully
Context 'localhost:8080' updated

로그인이 다 되었으면 application을 배포해도록 하겠습니다. 터미널에 다음 명령어를 입력합니다.

$ argocd app create guestbook --repo https://github.com/argoproj/argocd-example-apps.git --path guestbook --dest-server https://kubernetes.default.svc --dest-namespace default

위 명령어는 argocd(여기서는 argocd를 만들고 관리하는 단체를 의미한다.)에서 제공하는 예제 샘플을 우리가 구성한 ArgoCD로 배포하고 관리할 수 있는 객체를 생성합니다. 이 객체, 혹은 배포 단위를 argocd에서는 "application"이라고 합니다. ArgoCD UI로 돌아가보겠습니다.

아래 그림과 같이 애플리케이션이 구성되었음을 확인할 수 있습니다.

현재 노란 색깔이 보이는데, 아직 쿠버네티스 클러스터에 배포되지 않았음을 의미합니다. 여기서 "Sync"를 누르면 배포를 할 수 있습니다.

그럼 오른쪽에서 다음 UI가 발생하는데 "Synchronize"를 누릅니다.

그럼 얼마 있다가 색깔이 노란색에서 초록색으로 바뀌게 됩니다. 예제 샘플이 배포가 되었음을 의미합니다.

애플리케이션을 UI를 클릭해보면 어떤 리소스들이 구성되는지 확인할 수 있습니다.

위 UI에서 다음 리소스들이 생성되었음을 확인할 수 있습니다.

service x1 (endpoint, endpointslice는 서비스 생성 시 자동 구성됨)
deployment x1
replicaset x1
pod x1

실제 쿠버네티스에서 구성된 리소스들과 비교해보죠. 다음 명령어를 입력합니다.

$ kubectl get all | grep "guestbook"
pod/guestbook-ui-85985d774c-dk6gz   1/1     Running   0          7m16s
service/guestbook-ui   ClusterIP   10.104.51.32   <none>        80/TCP    7m16s
deployment.apps/guestbook-ui   1/1     1            1           7m16s
replicaset.apps/guestbook-ui-85985d774c   1         1         1       7m16s

정확하게 일치됨을 확인할 수 있습니다.

이 문서에서는 예제 샘플, 즉 저희가 코드 관리를 할 수 없기 때문에 코드 내용이 변경될 때 싱크를 맞춰서 배포됨을 확인할 수 없습니다. 하지만, 만약 자신의 레포를 설정했다면, 레포에 코드 변경이 발생할 시 최대 3분을 기다렸다가 ArgoCD가 쿠버네티스 클러스터에 싱크를 맞춰서 애플리케이션을 배포하는 것을 확인할 수 있습니다.

참고

ArgoCD 공식 문서 - "Getting Started"

그라파나 9 새로운 기능 (1) Query Builder

Gurumee — Fri, 2 Sep 2022 18:20:09 +0900

최근 Grafana 9 버전이 출시되었습니다. 사용자들의 편의성을 위한 많은 기능들이 업데이트 및 생성되었습니다. 이 문서에서는 새로운 기능 중 하나인 Query Builder에 대해서 간단하게 알아보겠습니다.

그라파나 9 이전에 쿼리하는 방법

예를 들어서 다음 쿼리를 Grafana를 통해서 조회한다고 해봅시다.

sum(rate(go_gc_duration_seconds{job="node-exporter"}[$__rate_interval]))

Grafana 9 이전 버전에서는 "Explore"를 탭에서 쿼리를 하는 UI는 다음과 같습니다.

기존 Grafana 8에서는 사용자가 하나 하나 쿼리를 모두 입력해야하는 불편함이 있었습니다.(물론 자동 완성 기능으로 어느 정도 커버가 가능합니다.)

그라파나 9 에서 쿼리하는 방법 (1) Query Builder

Grafana 9 버전부터는 Query Builder를 통해서 보다 쉽고 정확하게 그라파나를 통해서 데이터를 쿼리할 수 있습니다. (아직 "베타" 기능인게 함정.) 지금부터 Grafana 9에서 제공하는 Query Builder를 통해서 데이터를 조회하는 방법에 대해서 차근 차근 살펴보도록 하죠.

이제 "Explore" 탭으로 이동합니다. 그 후 아래 그림처럼 "Metric" 아래 드랍다운 UI에서 원하는 메트릭을 지정합니다.

그 후 필터링이 필요하다면 "Labels"에서 원하는 레이블과 값을 지정하면 됩니다. 이 문서에서는 1개만 지정하지만, 여러 개를 지정해줄 수 있습니다.

그 다음 집계 및 연산을 원한다면 "+ Operations"를 클릭합니다. 첫 연산 식으로는 "Range functions"의 "Rate"를 선택했습니다.

물론 여러 연산 식을 조합할 수 있습니다. 두번째 연산 식으로는 "Aggregate"의 "Sum"을 선택해보도록 하죠.

짜잔! 놀라운 점은 조합 방법을 순서대로 하지 않더라도 동일하게 동작하는 쿼리를 구성할 수 있다는 것입니다. 이렇게 조회하고 싶은 쿼리를 손쉽고 정확하게 만들어낼 수 있습니다.

쿼리의 결과는 이전 UI와 마찬가지로 아래 그림처럼 나타납니다.

그라파나 9 에서 쿼리하는 방법 (2) 기존 방식 그대로

물론 직접 쿼리를 작성하는게 편하시다면 왼쪽 상단에 "Code"를 클릭하여 기존 방식처럼 쿼리할 수 있습니다.

그럼 Grafana 9 이전 방식에서 쿼리를 작성했던 것처럼 직접 작성할 수 있는 UI를 확인할 수 있습니다.

참고

쿠버네티스에서 metrics-server 구성하기

Gurumee — Thu, 25 Aug 2022 22:07:02 +0900

개요

쿠버네티스 클러스터를 운영하다보면 파드, 노드들의 리소스들을 확인해야 할 때가 정말 빈번하게 일어납니다. 이럴 때, 유용한 명령어로 kubectl top 명령어가 있습니다. 한, 번 명령어를 입력해볼까요?

$ kubectl top po
error: Metrics API not available

위 로그를 확인할 수 있듯이 아쉽게도 기본적으로 제공되는 것은 아닙니다. 쿠버네티스 클러스터에 metrics-server라는 컴포넌트를 추가적으로 설치해주어야 합니다.

이 문서에서는 쿠버네티스 클러스터 minikube 환경에서 metrics-server를 구성하는 것에 대하여 다룹니다.

metrics-server 구성하기

먼저 다음 명령어를 이용하여 metrics-server를 설치할 수 있습니다.

$ kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
serviceaccount/metrics-server created
clusterrole.rbac.authorization.k8s.io/system:aggregated-metrics-reader created
clusterrole.rbac.authorization.k8s.io/system:metrics-server created
rolebinding.rbac.authorization.k8s.io/metrics-server-auth-reader created
clusterrolebinding.rbac.authorization.k8s.io/metrics-server:system:auth-delegator created
clusterrolebinding.rbac.authorization.k8s.io/system:metrics-server created
service/metrics-server created
deployment.apps/metrics-server created
apiservice.apiregistration.k8s.io/v1beta1.metrics.k8s.io created

설치가 됐으니 한 번 kubectl top 명령어를 사용해볼까요?

$ kubectl top po
Error from server (ServiceUnavailable): the server is currently unable to handle the request (get pods.metrics.k8s.io)

$ kubectl top no
Error from server (ServiceUnavailable): the server is currently unable to handle the request (get nodes.metrics.k8s.io)

이런.. 아직도 정상적으로 실행이 안됩니다. 왜 그런 것일까요? 한 번 로그를 살펴봅시다.

$ kubectl logs -n kube-system metrics-server-64cf6869bd-l9lmp
...
I0825 12:20:36.015508       1 server.go:187] "Failed probe" probe="metric-storage-ready" err="no metrics to serve"
I0825 12:20:38.629536       1 server.go:187] "Failed probe" probe="metric-storage-ready" err="no metrics to serve"

metrics-server는 기본적으로 kube-api-server와 https 통신을 통하여 노드/파드의 리소스들을 얻습니다. 하지만 minikube로 구성된 쿠버네티스 클러스터는 kube-api-server가 https 통신을 지원하지 않는 것으로 추정됩니다.

따라서 metrics-server 역시 https 통신을 하지 않도록 구성을 해주면 됩니다. 다음 명령어를 통해서, metrics-server에 전달하는 args를 수정합니다.

$ kubectl edit deployments.apps -n kube-system metrics-server

아래 그림처럼 다음 옵션들을 추가해줍니다.

--kubelet-insecure-tls
--kubelet-preferred-address-types=InternalIP

kubectl top 명령어 사용해보기

metrics-server가 쿠버네티스 클러스터에 정상적으로 설치가 되었다면 kubectl top 명령어가 활성화가 됩니다. 파드 단위의 리소스들을 모니터링하고 싶다면 kubectl top po를 이용하면 됩니다. 다만 네임스페이스 단위로 리소스들을 확인할 수 있습니다.

$ kubectl top po -n kube-system
NAME                               CPU(cores)   MEMORY(bytes)
coredns-78fcd69978-s5l6w           3m           11Mi
etcd-minikube                      30m          29Mi
kube-apiserver-minikube            126m         292Mi
kube-controller-manager-minikube   41m          43Mi
kube-proxy-2bzll                   2m           10Mi
kube-scheduler-minikube            5m           14Mi
metrics-server-7f6fdd8fc5-wzq5v    5m           13Mi
storage-provisioner                3m           8Mi

또한, kubectl top no 명령어를 사용하여 노드 단위의 리소스들을 확인할 수 있습니다.

$ kubectl top no
NAME       CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
minikube   275m         6%     610Mi           3%

참고

[kubernetes] docker desktop에서 구성된 kubernetes 클러스터에서 metrics-server가 정상적으로 동작하지 않을 때

Gurumee — Sun, 21 Aug 2022 20:44:39 +0900

개요

현재 개인적으로 진행하는 작업이 있어서, docker desktop에서 활성화한 kubernetes에서 pod/node 등의 메트릭 지표를 얻기 위해서 metrics-server를 설치했습니다. 이 때 만났던 문제들에 대해서 트러블슈팅하는 방법을 기록합니다.

환경:

docker v20.10.17
맥북 정보:
- cpu: 2.3 GHz 쿼드 코어 Intel Core i7
- mem: 32GB 3733 MHz LPDDR4X

metrics-server 설치 명령어:

$ kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

설치 이후 kubectl top 명령어 실행 결과:

$ kubectl top no
Error from server (ServiceUnavailable): the server is currently unable to handle the request (get nodes.metrics.k8s.io)

$ kubectl top po
Error from server (ServiceUnavailable): the server is currently unable to handle the request (get pods.metrics.k8s.io)

문제 #1 Error from server (ServiceUnavailable): the server is currently unable to handle the request

해당 문제는 metrics-server 파드의 로그를 보면 왜 에러가 나는지 알 수 있습니다.

$ kubectl logs -n kube-system metrics-server-678f4bf65b-lg5n6
...
I0821 11:32:44.142448       1 server.go:187] "Failed probe" probe="metric-storage-ready" err="no metrics to serve"
E0821 11:32:51.407435       1 scraper.go:140] "Failed to scrape node" err="Get \"https://192.168.65.4:10250/metrics/resource\": x509: cannot validate certificate for 192.168.65.4 because it doesn't contain any IP SANs" node="docker-desktop"

현재 로그에 따르면 metrics-server와 kube-api-server와 https 통신이 원활하게 이루어지지 않고 있음을 확인할 수 있습니다. 이 문제를 해결하는 가장 쉬운 방법은 metrics-server를 실행할 때 --kubelet-insecure-tls 플래그를 추가하는 것입니다.

터미널에 다음을 입력하여 metrics-server 디플로이먼트를 수정합니다.

$ kubectl edit deployments.apps -n kube-system metrics-server

그 후 아래 그림처럼 해당 플래그를 추가해줍니다.

이제 kubectl top 명령어를 입력해봅시다.

kubectl top 명령어 실행 결과:

$ kubectl top no
NAME             CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
docker-desktop   242m         6%     1567Mi          26%

$ kubectl top po -n kube-system
error: Metrics not available for pod kube-system/coredns-6d4b75cb6d-5db2z, age: 49m3.256834s

노드 단위는 정상 수행되지만 파드 단위에서 새로운 에러가 발생됩니다.

문제 #2 error: Metrics not available for pod

이 에러는 다음 이슈에서 해결 방법을 찾을 수 있었습니다. 이 문제의 근본적인 원인은 기본적으로 mac OS docker desktop이 설치되면 cri-dockerd v2.1.0이 도커 엔진으로 사용하는데 이 버전에서 버그가 있기 때문입니다.

따라서 그 버그가 해결된 v2.3.0으로 변경해줍니다. 아래 명령어를 잘 따라하면 됩니다. 먼저 로컬 Docker VM에 로그인합니다.

$ docker run -it --privileged --pid=host ubuntu nsenter -t 1 -m -u -n -i sh
Unable to find image 'ubuntu:latest' locally
latest: Pulling from library/ubuntu
d19f32bd9e41: Pull complete
Digest: sha256:34fea4f31bf187bc915536831fd0afc9d214755bf700b5cdb1336c82516d154e
Status: Downloaded newer image for ubuntu:latest
# ---- 여기서부터 docker vm 컨테이너에 접속됩니다.
# ---- (위치) # 으로 표시됩니다.
/ #

그 후 다음 명령어들을 이용해서 cri-dockerd v2.3.0를 설치합니다.

# ---- tmp로 이동
/ # cd /tmp/

# ---- cri-dockerd v2.3.0 다운로드
/tmp # wget https://github.com/Mirantis/cri-dockerd/releases/download/v0.2.3/cri-dockerd-0.2.3.arm64.tgz

# ---- cri-dockerd v2.3.0 압축 해제
/tmp # tar zxvf cri-dockerd-0.2.3.arm64.tgz
cri-dockerd/
cri-dockerd/cri-dockerd

설치된 cri-dockerd(v2.1.0) 바이너리 파일의 위치를 찾습니다.

/tmp # cd /
/ # find . -name "cri-dockerd"
./var/lib/kube-binary-cache-debian/cri-dockerd
./var/lib/docker/overlay2/057ad611e25d8e23d4d8f5b1dfe105f4bcb0dc2b784ef6f251cd11d91daa06c8/diff/binaries/cri-dockerd
./var/lib/docker/overlay2/a2b982b647747b7e3f29db8cfb5668279e47402b24ed0cbe8ddec256b3a112cc/diff/binaries/cri-dockerd
./var/lib/mount-services-cache/entries/services.tar/cfaf2b3b5d8c80d1fd63ca0acaa230bb7f027982b7783d8a9029e7c5fc0023be/containers/services/docker/rootfs/usr/bin/cri-dockerd
./var/lib/mount-services-cache/entries/services.tar/cfaf2b3b5d8c80d1fd63ca0acaa230bb7f027982b7783d8a9029e7c5fc0023be/containers/services/docker/tmp/upper/usr/bin/cri-dockerd
./var/lib/cri-dockerd
./tmp/cri-dockerd
./tmp/cri-dockerd/cri-dockerd
./containers/services/docker/rootfs/usr/bin/cri-dockerd             # --- 이부분
./containers/services/docker/tmp/upper/usr/bin/cri-dockerd          # --- 이부분

해당 위치가 찾고 있는 cri-dockerd(v2.1.0) 바이너리 파일이 맞는지 확인합니다.

/ # ./containers/services/docker/tmp/upper/usr/bin/cri-dockerd --version
cri-dockerd 0.2.1 (HEAD)

이제 cri-dockerd(v2.3.0)으로 대체합니다.

/ # cp /tmp/cri-dockerd/cri-dockerd /containers/services/docker/rootfs/usr/bin
/ # cp /tmp/cri-dockerd/cri-dockerd /var/lib/kube-binary-cache-debian/cri-dockerd
...

그 후 docker desktop을 재시작합니다. 그 후 kubectl top 명령어를 입력합니다.

kubectl top 명령어 실행 결과:

$ kubectl top no
NAME             CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
docker-desktop   341m         8%     1480Mi          25%

$ kubectl top po -n kube-system
NAME                                     CPU(cores)   MEMORY(bytes)
coredns-6d4b75cb6d-5db2z                 4m           11Mi
coredns-6d4b75cb6d-nwbqv                 4m           45Mi
etcd-docker-desktop                      36m          73Mi
kube-apiserver-docker-desktop            65m          390Mi
kube-controller-manager-docker-desktop   38m          115Mi
kube-proxy-x4fsh                         1m           50Mi
kube-scheduler-docker-desktop            7m           52Mi
kube-state-metrics-5b8455d88b-j57kx      1m           40Mi
metrics-server-658867cdb7-wzq2c          8m           54Mi
storage-provisioner                      3m           9Mi
vpnkit-controller                        0m           24Mi

모두 정상 수행되는 것을 확인할 수 있습니다.

[Golang] fatal error: concurrent map writes

Gurumee — Mon, 4 Apr 2022 19:19:12 +0900

문제 상황

golang 개발 중, map 객체에 어떤 값을 저장하여, 이를 이용하는 서비스를 만든다고 해보자. 처음에는 쉽게 다음과 같이 WriteMap 함수를 이용해서 코드를 간단하게 작성할 수 있다.

package main

import "fmt"

func WriteMap(m map[int]int, num int) {
    for i := 0; i < num; i++ {
        m[i] = i
    }
}

func main() {
    fmt.Println("map writes start!")
    m := map[int]int{}
    WriteMap(m, 100)
    fmt.Println("map writes end!")
}

이 때, 고루틴을 이용하여 WriteMap 함수의 성능 향상을 계획했다고 가정해보자. 그럼 코드는 이렇게 바꿀 수 있을 것이다.

package main

import "fmt"

func WriteMap(m map[int]int, num int) {
    for i := 0; i < num; i++ {
        go func() {
            m[i] = i
        }()
    }
}

func main() {
    fmt.Println("map writes start!")
    m := map[int]int{}
    WriteMap(m, 100)
    fmt.Println("map writes end!")
}

이 때 프로그램을 실행시키면, 다음 에러를 일으키는 것을 확인할 수 있다.

$ go run main.go 
map writes start!
fatal error: concurrent map writes

goroutine 12 [running]:
runtime.throw(0x10ca420, 0x15)
        /Users/gurumee/.gvm/gos/go1.16/src/runtime/panic.go:1117 +0x72 fp=0xc00004d760 sp=0xc00004d730 pc=0x10327f2
runtime.mapassign_fast64(0x10b1ce0, 0xc00007a180, 0x1e, 0x0)
        /Users/gurumee/.gvm/gos/go1.16/src/runtime/map_fast64.go:101 +0x33e fp=0xc00004d7a0 sp=0xc00004d760 pc=0x1010c3e
main.WriteMap.func1(0xc0000160c8, 0xc00007a180)
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:8 +0x45 fp=0xc00004d7d0 sp=0xc00004d7a0 pc=0x10a3365
runtime.goexit()
        /Users/gurumee/.gvm/gos/go1.16/src/runtime/asm_amd64.s:1371 +0x1 fp=0xc00004d7d8 sp=0xc00004d7d0 pc=0x1064361
created by main.WriteMap
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:7 +0x65

goroutine 1 [runnable]:
fmt.Fprintln(0x10e83a0, 0xc00000e018, 0xc000076f58, 0x1, 0x1, 0x12, 0x0, 0x0)
        /Users/gurumee/.gvm/gos/go1.16/src/fmt/print.go:262 +0xed
fmt.Println(...)
        /Users/gurumee/.gvm/gos/go1.16/src/fmt/print.go:274
main.main()
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:17 +0xe5

goroutine 9 [runnable]:
main.WriteMap.func1(0xc0000160c8, 0xc00007a180)
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:7
created by main.WriteMap
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:7 +0x65

goroutine 11 [runnable]:
main.WriteMap.func1(0xc0000160c8, 0xc00007a180)
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:7
created by main.WriteMap
        /Users/gurumee/Workspace/troubleshooting/go-concurrent-map-writes/main.go:7 +0x65
...

문제 원인

다음 문서를 보면, 그 실마리를 찾을 수 있다.

Why are map operations not defined to be atomic?

After long discussion it was decided that the typical use of maps did not require safe access from multiple goroutines, and in those cases where it did, the map was probably part of some larger data structure or computation that was already synchronized. Therefore requiring that all map operations grab a mutex would slow down most programs and add safety to few. This was not an easy decision, however, since it means uncontrolled map access can crash the program.

문서에 따르면, golang 개발진은 map 객체를 동시에 접근하는 상황을 일반적인 상황으로 보지 않았고, 따라서 표준 라이브러리에서 제공하는 map은 "atomic"한 연산을 지원하지 않는다. 쉽게 말해 동시성을 처리하는 연산을 지원하지 않는다는 뜻이다. 즉 위 WriteMap의 경우 num개 만큼 생성되는 고루틴들에서 map 객체를 동시에 접근하나, 이를 처리하지 않기 때문에 생기는 문제였다.

문제 해결

문제 해결 방법은 크게 2가지이다.

WaitGroup, Mutex Lock/Unlock을 이용한 동시성 제어
Channel을 이용한 동시성 제어

먼저 가장 쉬운 WaitGroup과 Mutex를 이용한 방법을 살펴보자. Mutex는 여러 스레드가 동시에 접근하는 객체에 한 스레드만 수행할 수 있도록 잠금을 해버린다. 한 스레드의 수행이 끝나야 다른 스레드의 수행이 실행될 수 있다. 다음과 같이 WriteMap을 수정하면 된다.

package main

import (
    "fmt"
    "sync"
)

func WriteMap(m map[int]int, num int) {
    mutex := &sync.Mutex{}
    wg := &sync.WaitGroup{}

    for i := 0; i < num; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            mutex.Lock()
            m[i] = i
            mutex.Unlock()
        }(i)
    }

    wg.Wait()
}

// ...

WaitGroup은 고루틴 개수만큼 카운터를 저장한다. 이 카운터가 0가 될 때까지 WriteMap 함수는 종료되지 않고 대기하게 된다. defer wg.Done() 구문 덕분에 고루틴이 종료되는 순간 풀에서 WaitGroup의 카운터를 줄이게 된다. 쉽게 말해서 동시에 접근하는 동안, 모든 고루틴이 실행을 마칠 때까지 기다리기 위해서 사용된다.

Mutex가 실제로 여러 고루틴이 동시에 접근할 때 순차적으로 접근할 수 있도록 잠금을 해주는 장치라고 보면 된다. 이 때, Lock과 Unlock이 쌍을 이루어야 한다는 점에 주의하자. 순서가 잘못되거나, 쌍이 맞지 않으면 여러 고루틴이 영원히 종료되지 않는 데드락 상황이 벌어지기 때문이다.

두 번째 방식은 Channel을 이용한 방식이다. 실제로 golang에서 수 많은 고루틴을 제어할 때 권장하는 방법이며 주로 select랑 같이 사용된다. 다음과 같이 코드를 변경하면 채널을 이용해서 여러 고루틴들을 제어할 수 있다.

package main

// ...

func WriteMapChan(m map[int]int, num int) {
    c := make(chan int)

    for i := 0; i < num; i++ {
        go func(i int) {
            c <- i
        }(i)
    }

    for i := 0; i < num; i++ {
        v := <-c
        m[v] = v
    }
}

// ...

channel은 보통 make(chan [type]) 형태로 만들어진다. 이들은 타입만 맞는다면 여러 고루틴이 값을 전송할 수 있는 일종의 통로가 된다. 즉, 첫 번째 for문에서, 다음과 같은 형태로 채널에 값을 전달하는 코드이다.

for i := 0; i < num; i++ {
    go func(i int) {
        c <- i        // 채널에 값을 전달
    }(i)
}

<-c는 채널에서 값을 빼온다는 구문이다. 즉 num개만큼 채널에 데이터를 전달했으니 그만큼 데이터를 빼와야 하는 것이다. 즉 두 번째 for문은 채널에서 값을 빼와 맵에 값을 넣는 방식이다.

for i := 0; i < num; i++ {
    v := <-c        // 채널에서 값을 빼옴
    m[v] = v        // 빼온 값을 맵객체에 넣음.
}

이 두 가지 중 하나를 적용했다면, "fatal error: concurrent map writes" 문제는 제거됨을 확인할 수 있다.

$ go run main.go
map writes start!
map writes end!

둘 다 장단점이 있다. WaitGroup/Mutex 방법은 코드 구조가 변경되지 않기 때문에 굉장히 직관적이다. 하지만 성능이 떨어진다. Channel 방식은 성능은 빠르나, 코드 구조를 살짝 바꿔줘야 하는 번거로움이 있다. 개인적으로는 Channel 방식이 숙달만 되면 확실히 더 편한 감이 있다.