주요글: 도커 시작하기

베이그런트(Vagrant)를 이용해서 우분투 설치하기

이 글에서는 단일 노드뿐만 아니라 다중 노드에 도커를 설치하고 실행하는 연습을 하기 위해 아래 환경을 사용한다.

  • 버추얼박스
  • 베이그런트

버추얼박스와 베이그런트를 차례대로 설치한 뒤에는 우분투 단일 노드 환경을 위한 Vagrant 파일을 작업할 폴더에 작성한다. 이 글에서는 E:\vn\vagrant\ubuntu 폴더에 Vagrant 파일을 생성했다고 가정한다.

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
  config.vm.network "private_network", ip: "192.168.1.2"
  config.vm.provider "virtualbox" do |vb|
    vb.memory = 2048
    vb.cpus = 2
  end
end

"ubuntu/bionic64"는 우분투 18.04 버전에 해당하는 베이그런트 박스 이미지다. 작업 폴더에서 vagrant up 명령어를 사용해서 우분투 서버를 구동한다.

E:\vm\vagrant\ubuntu>vagrant up
...생략

E:\vm\vagrant\ubuntu>vagrant ssh
Welcome to Ubuntu 18.04.2 LTS (GNU/Linux 4.15.0-54-generic x86_64)
...생략

vagrant ssh로 우분투 서버에 접속하고 도커 설치를 위해 root 계정으로 전환한다. "sudo su -" 명령어를 사용해서 root 계정으로 전환할 수 있다.

vagrant@ubuntu-bionic:~$ sudo su -
root@ubuntu-bionic:~#

우분투에 도커 설치하기

https://docs.docker.com/install/linux/docker-ce/ubuntu/ 사이트를 참고해서 우분투에 도커 커뮤니티 버전을 설치한다. 아래는 설치 과정에서 명령어만 정리한 것이다.

도커 리포지토리 설치

apt 패키지 인덱스 업데이트

# apt-get update

apt가 HTTPS 기반 리포지토리 사용하도록 설정

# apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

도커 공식 GPG 키 추가

# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | apt-key add -  
# apt-key fingerprint 0EBFCD88   
pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88   
uid           [ unknown] Docker Release (CE deb) <docker@docker.com>   
sub   rsa4096 2017-02-22 [S]

리포지토리 추가

# add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

도커 엔진 설치

apt 패키지 인덱스 업데이트

# apt-get update

도커 설치

# apt-get install docker-ce docker-ce-cli containerd.io

도커 실행 확인(root 계정으로 실행)

root@ubuntu-bionic:~# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete
Digest: sha256:b8ba256769a0ac28dd126d584e0a2011cd2877f3f76e093a7ae560f2a5301c00
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

docker run 명령어가 어떻게 동작하는지는 뒤에서 설명한다. 일단 지금은 hello-world라는 도커 이미지를 다운로드 받아 실행한다는 정도로만 이해하고 넘어가자.

root 아닌 계정으로 도커 실행하기

docker 명령어는 root 권한을 가진 계정으로 실행해야 한다. 일반 계정은 sudo를 이용해서 docker 명령어를 실행해야 한다. 매번 sudo를 입력하는 귀찮다면 docker 그룹에 사용자를 추가하면 된다. 다음은 현재 사용자를 docker 그룹에 추가하는 명령어 실행 순서를 표시한 것이다. 자세한 내용은 https://docs.docker.com/install/linux/linux-postinstall/ 문서를 참고한다.

  1. 현재 사용자를 docker 그룹에 추가: sudo usermod -aG docker $USER
  2. 그룹 추가를 현재 콘솔에 반영: newgrp docker
  3. 실행 확인: docker run hello-world

관련 글

logs 테이블의 id 칼럼이 자동 증가 칼럼이라고 하자. 최근 id 칼럼 값이 4라고 할때 이 칼럼에 P1, P2, P3과 아래 그림과 같은 순서로 insert 쿼리를 실행한다고 하자.

P1이 세 번의 insert 쿼리를 실행하면 id 값은 5, 6, 7이 된다. P1의 트랜잭션이 끝나지 않은 상태에서 P2, P3가 각각 insert 쿼리를 실행하면 ID는 8, 9가 된다. P2와 P3는 트랜잭션이 끝나고 P1이 아직 트랜잭션 진행 중인 상태에서 P4가 id를 조회하면 [8, 9]를 리턴한다.

일정 간격으로 데이터를 복사할 경우 이 상황은 문제가 될 수 있다. 예를 들어 다음 로직을 사용해서 최신 데이터를 처리하는 로직이 있다고 하자.

  1. 이전에 처리한 최대 ID를 구해 lastProcessedId에 할당한다.
  2. 현재의 최대 ID를 구해 maxId에 할당한다.
  3. lastProcessedId보다 크고 maxId보다 작거나 같은 ID의 값 목록을 구해 ids에 할당한다.
  4. ids에 속한 데이터를 처리한다.

만약 lastProcessedId가 4이고 P4의 조회 시점에 maxId는 9라고 하자. 이 경우 과정 3에서 구하는 ids에는 5, 6, 7은 없고 8, 9만 담긴다. 과정 4를 처리한 뒤 다시 과정 1을 반복하면 이때 lastProcessedId는 9가 되어 5, 6, 7은 처리 대상에서 누락되는 문제가 발생한다.

이런 누락 문제가 발생하지 않도록 하려면 트랜잭션 격리 레벨을 높이거나 데이터 조회 시점과 최대 ID가 증가하는 시점에 차이를 둬야 한다. CDC(Change Data Capture)를 사용하는 방법도 있다.

  1. 애니멀봐 다시보기 2020.07.21 10:57

    잘 보고 갑니다~~

이 글에서는 메이븐 프로젝트를 이클립스나 인텔리J에서 임포트하는 방법을 살펴보자.

이클립스에서 메이븐 프로젝트 임포트하기

이클립스에서 [File] -> [Import] 메뉴를 실행한다.

[그림1]

실행한 뒤 Import 대화창에서 Maven/Existing Maven Projects를 선택하고 [Next]를 클릭한다.

[그림2]

[그림2]에서 [Browse] 버튼을 클릭해서 pom.xml 파일이 위치한 폴더를 Root Directory로 선택하고 [Finish] 버튼을 클릭한다. 임포트가 끝나면 다음 그림처럼 이클립스에 프로젝트가 표시된다.

[그림3]

인텔리J에서 이클립스 프로젝트 임포트하기

인텔리J의 [File] -> [Open] 메뉴를 실행한다. Welcome 대화창에서는 Open 메뉴를 실행한다.

[그림4]

Open File or Project 대화창에서 메이븐 프로젝트 폴더를 선택하고 [OK] 버튼을 클릭한다. 잠시후 임포트가 끝나면 다음 그림처럼 프로젝트를 임포트한 결과를 확인할 수 있다.

[그림5]

 

  1. 감사합니다 2020.10.04 03:03

    감사합니다

MySQL이나 MariaDB에서 inet_aton/inet_ntoa 함수를 사용하면 문자열로 된 IP 주소를 정수로 저장할 수 있어 저장 용량을 줄이는데 도움이 된다. JPA를 사용하면 AttributeConverter를 사용해서 유사한 변환을 처리할 수 있다.

inet_aton과 inet_ntoa 구현

먼저 다음은 문자열과 정수 간 변환을 처리하는 코드이다.

object Inets {
    const val p3_256 = 256L * 256L * 256L
    const val p2_256 = 256L * 256L

    fun aton(ip: String?): Long? {
        if (ip == null) return null
        val vals: List<Int> = ip.split(".").filter { it.isNotEmpty() }.map { Integer.parseInt(it) }
        if (vals.isEmpty()) return null
        if (vals.size == 1) return vals[0].toLong()
        if (vals.size == 2) return vals[0] * p3_256 + vals[1]
        if (vals.size == 3) return vals[0] * p3_256 + vals[1] * p2_256 + vals[2]
        else return vals[0] * p3_256 + vals[1] * p2_256 + vals[2] * 256L + vals[3]
    }

    fun ntoa(num: Long?): String? {
        if (num == null) return null

        val d = num % 256
        val c = num / 256 % 256
        val b = num / (p2_256) % 256
        val a = num / (p3_256) % 256
        return "$a.$b.$c.$d"
    }
}

MySQL의 inet_aton()에 맞춰 구현했다. 예를 들어 inet_aton()은 "1.1"을 "1.0.0.1"과 동일한 값으로 변환한다. 또 "1.1.1"은 "1.1.0.1"과 같게 변환하고 "1"은 "0.0.0.1"과 같게 변환한다. 이 규칙에 맞게 Inets.aton()을 구현했다.

JPA 컨버터

다음은 Inets를 이용해서 구현한 JPA 컨버터이다.

import javax.persistence.AttributeConverter
import javax.persistence.Converter

@Converter
class InetConverter : AttributeConverter<String, Long> {
    override fun convertToDatabaseColumn(ip: String?): Long? {
        return Inets.aton(ip)
    }

    override fun convertToEntityAttribute(num: Long?): String? {
        return Inets.ntoa(num)
    }

}

사용

다음은 InetConverter를 사용한 코드 예이다.

@Convert(converter = InetConverter::class)
@Column(name = "reg_ip")
val ip: String?

 

다음과 같은 요구사항을 처리할 일이 생겨 분산 락이 필요했다.

  • 어플리케이션에 1분 간격으로 실행하는 작업이 있음
  • 이 작업은 한 쓰레드에서만 실행해야 함
  • 여러 장비에서 어플리케이션을 실행할 수 있음

Zookeeper나 Consul 같은 서비스를 사용하고 있지 않아 DB를 이용해서 단순하게 분산 락을 구현했다.

락 정보 저장 테이블

락 정보를 담을 DB 테이블 구조는 다음과 같이 단순하다.

name은 락 이름, owner는 락 소유자를 구분하기 위한 값, expiry는 락 소유 만료 시간이다.

다음은 MySQL을 위한 테이블 생성 쿼리이다.

CREATE TABLE dist_lock
(
    name   varchar(100) NOT NULL COMMENT '락 이름',
    owner  varchar(100) NOT NULL COMMENT '락 소유자',
    expiry datetime     NOT NULL COMMENT '락 만료 시간',
    primary key (name)
)

 

분산 락 동작

분산 락이 필요한 쓰레드(프로세스)는 다음과 같은 절차에 따라 락을 구한다.

  1. 트랜잭션을 시작한다.
  2. select for update 쿼리를 이용해서 구하고자 하는 행을 점유한다.
  3. owner가 다른데 아직 expiry가 지나지 않았으면 락 점유에 실패한다.
  4. owner가 다른데 expiry가 지났으면 락 owner를 나로 바꾸고 expiry를 점유할 시간에 맞게 변경한다.
  5. owner가 나와 같으면 expiry를 점유할 시간에 맞게 변경한다.
  6. 트랜잭션을 커밋한다.
  7. 락 점유에 성공하면(4, 5) 원하는 기능을 실행한다.
  8. 락 점유에 실패하면(3) 원하는 기능을 실행하지 않는다.

DB 락 구현

실제 락을 구현할 차례다. 원하는 코드 형태는 대략 다음과 같다.

lock.runInLock(락이름, 락지속시간, () -> {
    // 락을 구하면 수행할 작업
});

다음은 DB 테이블을 이용한 분산 락 구현 코드이다.

import javax.sql.DataSource;
import java.sql.*;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.UUID;

public class DbLock {
    private final String ownerId;
    private final DataSource dataSource;

    public DbLock(DataSource dataSource) {
        this.dataSource = dataSource;
        this.ownerId = UUID.randomUUID().toString();
    }

    public void runInLock(String name, Duration duration, Runnable runnable) {
        if (getLock(name, duration)) {
            runnable.run();
        }
    }

    private boolean getLock(String name, Duration duration) {
        Connection conn = null;
        boolean owned;
        try {
            conn = dataSource.getConnection();
            conn.setAutoCommit(false);
            OwnerInfo ownerInfo = getLockOwner(conn, name);
            if (ownerInfo == null) {
                insertLockOwner(conn, name, duration);
                owned = true;
            } else if (ownerInfo.owner.equals(this.ownerId)) {
                updateLockOwner(conn, name, duration);
                owned = true;
            } else if (ownerInfo.expiry.isBefore(LocalDateTime.now())) {
                updateLockOwner(conn, name, duration);
                owned = true;
            } else {
                owned = false;
            }
            conn.commit();
        } catch (Exception e) {
            owned = false;
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException ex) {
                }
            }
        } finally {
            if (conn != null) {
                try {
                    conn.setAutoCommit(false);
                } catch(SQLException ex) {}
                try {
                    conn.close();
                } catch (SQLException e) {
                }
            }
        }
        return owned;
    }

    private OwnerInfo getLockOwner(Connection conn, String name) throws SQLException {
        try (PreparedStatement pstmt = conn.prepareStatement(
                "select * from dist_lock where name = ? for update")) {
            pstmt.setString(1, name);
            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    return new OwnerInfo(
                            rs.getString("owner"),
                            rs.getTimestamp("expiry").toLocalDateTime());
                }
            }
        }
        return null;
    }

    private void insertLockOwner(Connection conn, String name, Duration duration) 
    throws SQLException {
        try(PreparedStatement pstmt = conn.prepareStatement(
                "insert into dist_lock values (?, ?, ?)")) {
            pstmt.setString(1, name);
            pstmt.setString(2, ownerId);
            pstmt.setTimestamp(3, 
                Timestamp.valueOf(
                    LocalDateTime.now().plusSeconds(duration.getSeconds()))
            );
            pstmt.executeUpdate();
        }
    }

    private void updateLockOwner(Connection conn, String name, Duration duration) 
    throws SQLException {
        try(PreparedStatement pstmt = conn.prepareStatement(
                "update dist_lock set owner = ?, expiry = ? where name = ?")) {
            pstmt.setString(1, ownerId);
            pstmt.setTimestamp(2, 
                Timestamp.valueOf(
                    LocalDateTime.now().plusSeconds(duration.getSeconds()))
            );
            pstmt.setString(3, name);
            pstmt.executeUpdate();
        }
    }
}

https://github.com/madvirus/db-lock-sample 에서 코드를 확인할 수 있다.

추가 고려사항

현재 구현은 당장의 요구를 충족하는데 필요한 만큼만 기능을 구현한 것으로 다음을 고려한 개선이 필요하다.

  • runInLock()에서 실행하는 코드의 실행 시간이 락 지속 시간보다 길면 안 됨
  • 명시적으로 락을 해제하는 기능 없음

 

스프링 데이터 JPA 기능 중에서 Pageable과 Page를 사용하면 쉽게 페이징 처리를 할 수 있어 편리하다. 하지만 특정 행부터 일정 개수의 데이터를 조회하고 싶은 경우에는 Pageable과 Page가 적합하지 않다(예를 들어 21번째 행부터 21개의 데이터를 읽어오고 싶은 경우). 특정 행부터 일정 개수의 데이터를 조회할 수 있는 기능을 모든 리포지토리에 적용할 필요가 생겼는데 이를 위해 다음 작업을 진행했다.

  • Rangeable 클래스 추가 : 조회할 범위 값 저장(Pageable 대체).
  • RangeableExecutor 인터페이스 : Rangeable 타입을 사용하는 조회 메서드 정의.
  • RangeableRepository 인터페이스 : 스프링 데이터 JPA Repository 인터페이스와 RangeableExecutor 인터페이스를 상속.
  • RangeableRepositoryImpl 클래스 : 스프링 데이터 JPA의 기본 구현체를 확장. RangeableRepository 인터페이스의 구현을 제공.

스프링 데이터 JPA에서 모든 리포지토리에 동일 기능을 추가하는 방법은 스프링 데이터 JPA 레퍼런스를 참고한다.

예제 코드 : https://github.com/madvirus/spring-data-jpa-rangeable

 

madvirus/spring-data-jpa-rangeable

init. Contribute to madvirus/spring-data-jpa-rangeable development by creating an account on GitHub.

github.com

Rangeable 클래스

import org.springframework.data.domain.Sort;

public class Rangeable {
    private int start;
    private int limit;
    private Sort sort;

    public Rangeable(int start, int limit, Sort sort) {
        this.start = start;
        this.limit = limit;
        this.sort = sort;
    }

    public int getStart() {
        return start;
    }

    public int getLimit() {
        return limit;
    }

    public Sort getSort() {
        return sort;
    }
}

* start : 시작행, limit : 개수, sort : 정렬

RangeableExecutor 인터페이스

import org.springframework.data.jpa.domain.Specification;

import java.util.List;

public interface RangeableExecutor<T> {
    List<T> getRange(Specification<T> spec, Rangeable rangeable);
}

RangeableRepository 인터페이스

import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.Repository;

import java.io.Serializable;

@NoRepositoryBean
public interface RangeableRepository<T, ID extends Serializable>
        extends Repository<T, ID>, RangeableExecutor<T> {
}

RangeableRepositoryImpl 클래스

import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.support.JpaEntityInformation;
import org.springframework.data.jpa.repository.support.SimpleJpaRepository;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import java.io.Serializable;
import java.util.List;

public class RangeableRepositoryImpl<T, ID extends Serializable>
        extends SimpleJpaRepository<T, ID>
        implements RangeableRepository<T, ID> {

    public RangeableRepositoryImpl(
            JpaEntityInformation<T, ?> entityInformation, 
            EntityManager entityManager) {
        super(entityInformation, entityManager);
    }

    @Override
    public List<T> getRange(Specification<T> spec, Rangeable rangeable) {
        TypedQuery<T> query = getQuery(
                spec, getDomainClass(), rangeable.getSort());

        query.setFirstResult(rangeable.getStart());
        query.setMaxResults(rangeable.getLimit());

        return query.getResultList();
    }
}

* 기본 구현체인 SimpleJpaRepository 클래스를 확장해서 getRange() 구현

@EnableJpaRepositories로 기본 구현 지정

import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@Configuration
@EnableJpaRepositories(repositoryBaseClass = RangeableRepositoryImpl.class)
public class SpringJpaConfiguration {
}

리포지토리에서 RangeableExecutor 인터페이스 사용

import org.springframework.data.repository.Repository;
import rangeable.jpa.RangeableExecutor;

public interface CommentRepository 
        extends Repository<Comment, Long>, RangeableExecutor<Comment> {
}

Rangeable로 일정 범위 조회

List<Comment> comments = repository.getRange(
        someSpec,
        new Rangeable(10, 5, Sort.by("id").descending()));

 

  1. 한입만 시즌2 2020.07.16 11:25

    잘 보고 갑니다~~

MockK는 코틀린을 위한 Mock 프레임워크이다. 자바에서 주로 사용하는 Mockito와 유사해서 약간만 노력하면 쉽게 적응할 수 있다. 이 글에서는 MockK의 간단한 사용법을 소개하며 더 다양한 사용법은 https://mockk.io/ 사이트에서 확인할 수 있다.

의존 설정

MockK를 사용하려면 먼저 다음 의존을 추가한다.

<dependency>
    <groupId>io.mockk</groupId>
    <artifactId>mockk</artifactId>
    <version>1.9.3</version>
    <scope>test</scope>
</dependency>

코틀린 1.2 버전을 사용하면 1.9.3.kotlin12 버전을 사용한다.

모의 객체 생성

io.mockk.mockk 함수를 이용해서 모의 객체를 생성한다. 다음은 생성 예이다.

// 1. mockk<타입>()
private val mockValidator1 = mockk<CreationValidator>()

// 2. 타입 추론
private val mockValidator2 : CreationValidator = mockk()

mockk 함수는 타입 파라미터를 이용해서 생성할 모의 객체의 타입을 전달받는다. 변수나 프로퍼티의 타입이 명시적으로 정의되어 있으면 타입 추론이 가능하므로 생략해도 된다.

Answer 정의

모의 객체를 생성했다면 모의 객체가 어떻게 동작할지 정의할 차례이다. 아주 간단하다. io.mockk.every 함수를 사용하면 된다. 다음은 예이다.

@Test
fun someMockTest() {
    every { mock.someMethod(1) } returns "OK" // "OK" 리턴
    every { mock.someMethod(2) } throws SomeException() // 익셉션 발생
    every { mock.call() } just Runs // Unit 함수 실행
    
    assertEquals("OK", mock.someMethod(1))
    assertThrows<SomeException> { mock.someMethod(2) }
}

임의의 인자와 일치

임의의 인자 값과 일치하도록 설정하려면 any()를 사용한다.

@Test
fun someMockTest() {
    every { mock.anyMethod(any(), 3) } returns "OK"
    
    assertEquals("OK", mock.anyMethod(10, 3))
}

Relaxed mock

MockK는 호출 대상에 대한 스텁 정의를 하지 않으면 오류를 발생한다. 

val mock = mockk<Some>()

mock.someMethod(1) // --> io.mockk.MockKException: no answer found for: Some(#1).someMethod(1)

이를 완화하는 방법은 Relaxed mock을 생성하는 것이다. mockk()의 relaxed 파라미터 값을 true로 전달하면 Relaxed mock을 생성할 수 있다.

val mock = mockk<Some>(relaxed = true)
mock.someMethod(1) // --> 0 리턴

리턴 타입이 Unit인 함수는 relaxUnitFun 파라미터 값을 true로 전달한다.

호출 여부 검증

io.mockk.verify 함수를 사용해서 호출 여부를 검증할 수 있다.

val mock = mockk<Some>(relaxed = true)

mock.someMethod(1)
mock.anyMethod(1, 3)

verify { mock.someMethod(1) }
verify { mock.anyMethod(any(), 3) }

인자 캡처

인자를 캡처하고 싶을 땐 slot()과 capture()를 사용한다. 다음은 사용 예를 보여준다.

val mock = mockk<Some>()

val argSlot = slot<Int>()
every { mock.someMethod(capture(argSlot)) } returns 3

mock.someMethod(5)

val realArg = argSlot.captured
assertEquals(5, realArg)

이 글에서는 기본적인 MockK의 사용법을 소개했다. MockK는 더 다양한 기능을 제공하므로 https://mockk.io 사이트를 구경해보자. 도움이 되는 기능을 찾을 수 있을 것이다.

졸업 전만 해도 굉장한 개발자가 되고 싶었다. 뛰어난 설계 능력과 코딩 속도를 자랑하는 그런 실력자 말이다. 이런 막연한 목표는 오래가지 않아 사라졌다. 3-4년 정도 경력을 쌓는 동안 '적당히 잘하는 개발자'로 원하는 수준이 바뀌었다. 언제인지도 모르게 '굉장한' 개발자가 되기 어렵다는 걸 깨닫고 나름 노력하면 될 수 있는 '적당히 잘하는'으로 목표를 낮춘 것이다. 회사 생활을 하면서 뭔가 대단한 걸 만들 재주가 없다는 것을 알게 되었고 남이 만든 거라도 잘 쓰면 다행이란 생각을 하시 시작했다.

사회 초년기에 또 하나 깨달은 건 '기술'만으로는 일이 되지 않으며 기술은 일이 되게 하는 여러 요소 중 하나라는 사실이었다. 기술력이 없으면 안 되는 경우도 있겠지만 꽤 많은 프로젝트가 기술 난이도가 아닌 다른 이유로 실패하는 것을 경험했다. 기술에 대한 욕심이 줄고 다가올 일을 수행하는데 필요한 역량에 초점을 맞추기 시작한 것도 이 시기이다.

다다르고 싶은 수준이 내려가고 기술 외에 다른 것도 있다는 걸 알게 되면서 접하는 책의 주제도 다양해졌다. '피플 웨어', '테크니컬 리더(BTL)', '프로젝트 생존 전략', '스크럼'과 같이 구현 기술은 아니지만 개발과 연관된 책을 읽기 시작했다. '썩은사과'나 '인간력'과 같은 사람에 대한 책도 읽기 시작했다. 이런 책은 개발에 대한 시야를 넓히는데 도움이 되었다.

적당히 잘하기 위해 생산성을 높여야 했고 이를 위해 테스트 코드처럼 효율을 높이는 수단을 찾아 학습했다. 남들이 좋다고 하는 지식도 일부 학습했다. 당장 이해할 수 없는 주제가 많았지만 여러 번 책을 읽고 실제로 적용해 보면서 체득하려고 노력했다. 이런 지식은 개발하는 사고의 틀을 제공해 주었고 생산성을 높여주는 밑거름이 되었다.

많은 뛰어난 개발자가 좋다고 알려준 것도 다 못하고 있고, 배틀을 해서 이길 만큼 개발 지식이 넓지도 깊지도 않으며, 개발 리더로서의 자질도 부족해 팀장 역할이 힘겨울 때가 많다. 애초에 높은 경지가 목표가 아니었기에 당연한 모습이다. 그래도 위안을 삼자면 적당히 잘하는 수준은 되었다는 것이다. 최고의 결과를 만들어내는 고수는 아니나 그래도 중간 이상의 결과는 만들 수 있는 개발자는 되었다.

꽤 긴 경력에 이 정도 밖에 도달하지 못했지만 그래도 이게 어딘가! 20대 초반에 상상한 그런 초고수는 아니지만 지금의 모습에 아쉬움은 없다. 부족한 게 많지만 조금 더 갈고닦아 지금보다 조금이라도 나아질 수 있다면 그걸로 족하다.

  1. 빡빡이발레리나 2019.06.25 11:32

    저도 개발을 오래 하면서 생각이 많이 바뀌었습니다.
    저 역시 모든것을 다 알아야 하고 막힘없이 해결하고 다른 사람들에게 기술적으로 인정을 벋는 그런 사람이 되려 했지만 그런점들이 프로젝트를 하면서 보여지든 보여지지 않든 프로젝트의 결과를 향해 가는 항해에 방해가 되는 점이라는 생각이 어느날 들더군요.

    글을 잘 안남기지만 생각이 비슷하고 글을 읽고 머리가 환기되기에 적어 봅니다.

    좋은글 감사합니다.

  2. 공감합니다 2020.08.11 14:46

    저도 3년차를 넘어가면서 생각이 바뀌었습니다.
    정말 열심히 모든 것을 다 배워주마 하고 공부했던 시절이 있었지만,
    인생에 시간도 충분치 않고 매우 훌륭하다고 생각하지도 않기 때문에...
    조금씩만 나아지면 좋겠다고 생각합니다.

  3. 2020.10.19 13:49

    비밀댓글입니다

    • 최범균 madvirus 2020.10.20 08:28 신고

      안녕하세요. 영상에서 제 이름과(최범균)과 블로그 이름(자바캔)을 함께 언급해 주셨으면 합니다.

  4. 2020.10.20 09:42

    비밀댓글입니다


Centos 7 버전에 쿠버네티스(kubernetes)를 설치하는 과정을 정리한다. 보다 자세한 내용은 다음 문서를 참고한다.

 

0. Centos 7 준비

쿠버네티스 테스트 용도로 세 개의 가상 머신을 준비했다. 각 가상 머신에 Centos 7을 설치했고 IP와 호스트 이름을 다음과 같이 설정했다.

  • 172.16.1.100 k8s-master
  • 172.16.1.101 k8s-node1
  • 172.16.1.102 k8s-node2
각 서버의 /etc/hosts 파일에도 위 내용을 추가했다.

[Centos 7 호스트 이름 변경 명령어]

hostnamectl을 사용하면 Centos에서 호스트 이름을 변경할 수 있다.

# hostnamectl set-hostname 호스트이름


1. 도커 설치

전체 서버에 도커를 설치한다. https://docs.docker.com/install/linux/docker-ce/centos/ 문서를 참고해서 설치했다.


# yum install -y yum-utils device-mapper-persistent-data lvm2


# yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo


# yum install docker-ce


# systemctl start docker && systemctl enable docker


2. kubeadm 설치 준비

kubeadm을 설치하려면 몇 가지 준비를 해야 한다. 전체 서버에서 다음을 진행한다.


SELinux 설정을 permissive 모드로 변경


# setenforce 0


# sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config


iptable 설정


# cat <<EOF >  /etc/sysctl.d/k8s.conf

net.bridge.bridge-nf-call-ip6tables = 1

net.bridge.bridge-nf-call-iptables = 1

EOF

$ sysctl --system


firewalld 비활성화


# systemctl stop firewalld

# systemctl disable firewalld


스왑 오프


스왑 끄기:

# swapoff -a


/etc/fstab 파일에 아래 코드 주석 처리:

#/dev/mapper/centos-swap swap                    swap    defaults        0 0


서버 재시작:

# reboot



3. 쿠버네티스 설치 준비

쿠버네티스 YUM 리포지토리 설정:

# cat <<EOF > /etc/yum.repos.d/kubernetes.repo

[kubernetes]

name=Kubernetes

baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64

enabled=1

gpgcheck=1

repo_gpgcheck=1

gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

exclude=kube*

EOF


kubeadm 설치:

# yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes


# systemctl enable kubelet && systemctl start kubelet



[쿠버네티스 구성 요소]

쿠버네티스를 구성하는 컴포넌트에 대해 알고 싶다면 https://kubernetes.io/ko/docs/concepts/overview/components/ 문서를 읽어보자. 이 문서를 빠르게 훑어보고 다음 내용을 진행하면 설치 과정에서 용어나 메시지를 이해하는데 도움이 된다.


4. 마스터 컴포넌트 설치

kubeadm init 명령으로 마스터 노드 초기화


kubeadm init 명령어를 이용해서 마스터 노드를 초기화한다. --pod-network-cidr 옵션은 사용할 CNI(Container Network Interface)에 맞게 입력한다. 이 글에서는 CNI로 Flannel을 사용한다고 가정한다.


# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=172.16.1.100

...생략

[addons] Applied essential addon: CoreDNS

[addons] Applied essential addon: kube-proxy


Your Kubernetes master has initialized successfully!


To start using your cluster, you need to run the following as a regular user:


  mkdir -p $HOME/.kube

  sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

  sudo chown $(id -u):$(id -g) $HOME/.kube/config


You should now deploy a pod network to the cluster.

Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:

  https://kubernetes.io/docs/concepts/cluster-administration/addons/


You can now join any number of machines by running the following on each node

as root:


  kubeadm join 172.16.1.100:6443 --token yrc47a.55b25p2dhe14pzd1 --discovery-token-ca-cert-hash sha256:2a7a31510b9a0b0da1cf71c2c29627b40711cdd84be12944a713ce2af2d5d148



마스터 초기화에 성공하면 마지막에 'kubeadm join ....'으로 시작하는 명령어가 출력된다. 이 명령어를 이용해서 작업 노드를 설치하므로 잘 복사해 놓자.


환경 변수 설정

root 계정을 이용해서 kubectl을 실행할 경우 다음 환경 변수를 설정한다.


# export KUBECONFIG=/etc/kubernetes/admin.conf


CNI 설치

이 글에서는 Flannel을 설치한다. 설치 명령어는 다음과 같다.


# kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/bc79dd1505b0c8681ece4de4c0d86c5cd2643275/Documentation/kube-flannel.yml


각 CNI별 설치 명령어는 Creating a single master cluster with kubeadm 문서를 참고한다.


마스터 실행 확인


마스터를 설치했다. 다음 명령어를 실행해서 결과를 확인한다.


# kubectl get pods --all-namespaces

NAMESPACE     NAME                                 READY   STATUS    RESTARTS   AGE

kube-system   coredns-86c58d9df4-78jbg             1/1     Running   0          9m3s

kube-system   coredns-86c58d9df4-q7mwf             1/1     Running   0          9m3s

kube-system   etcd-k8s-master                      1/1     Running   0          13m

kube-system   kube-apiserver-k8s-master            1/1     Running   0          13m

kube-system   kube-controller-manager-k8s-master   1/1     Running   0          13m

kube-system   kube-flannel-ds-amd64-zv8nc          1/1     Running   0          3m11s

kube-system   kube-proxy-xj7hg                     1/1     Running   0          14m

kube-system   kube-scheduler-k8s-master            1/1     Running   0          13m


5. 노드 컴포넌트 설치

kubeadm init 명령을 이용해서 설치할 때 콘솔에 출력된 메시지에 kubeadm join 명령어가 있었다. 이 명령어를 노드 컴포넌트로 사용할 서버에서 실행한다. 이 예에서는 k8s-node1 서버에서 아래 명령어를 실행했다.


# kubeadm join 172.16.1.100:6443 --token yrc47a.55b25p2dhe14pzd1 --discovery-token-ca-cert-hash sha256:2a7a31510b9a0b0da1cf71c2c29627b40711cdd84be12944a713ce2af2d5d148


첫 번째 슬레이브 노드 추가 후 마스터 노드에서 kubectl get nodes 명령을 실행해보자. master 역할을 하는 k8s-master 노드와 방금 추가한 k8s-node1이 노드 목록에 표시된다. 노드를 추가하자 마자 노드 목록을 조회하면 다음 처럼 아직 사용 준비가 안 된 NotReady 상태임을 알 수 있다.


[root@k8s-master ~]# kubectl get nodes

NAME         STATUS     ROLES    AGE   VERSION

k8s-master   Ready      master   18m   v1.13.2

k8s-node1    NotReady   <none>   30s   v1.13.2


k8s-node2 노드에서 두 번째 슬레이브 노드를 추가한 뒤에 다시 노드 목록을 살펴보자. 새로 추가한 노드가 목록에 보인다.


[root@k8s-master ~]# kubectl get nodes

NAME         STATUS     ROLES    AGE     VERSION

k8s-master   Ready      master   21m     v1.13.2

k8s-node1    Ready      <none>   3m28s   v1.13.2

k8s-node2    NotReady   <none>   15s     v1.13.2


kubectl cluster-info 명령어를 실행하면 클러스터 정보를 확인할 수 있다.


[root@k8s-master ~]# kubectl cluster-info

Kubernetes master is running at https://172.16.1.100:6443

KubeDNS is running at https://172.16.1.100:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy


To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.


6. 클러스터 테스트

마스터와 슬레이브를 설치했으니 간단한 예제를 실행해보자.


luksa/kubia 도커 컨테이너 이미지를 이용해서 팟 만들기:


요즘 학습하고 있는 '쿠버네티스 인 액셕' 책의 예제로 테스트했다. 다음 명령을 실행하자.


# kubectl run kubia --image=luksa/kubia --port 8080 --generator=run-pod/v1

replicationcontroller/kubia created


이 명령은 도커 이미지(luksa/kubia)를 이용해서 쿠버네티스 배포 단위인 파드(pod)를 클러스터에서 실행한다. 참고로 luksa/kubia 이미지는 호스트 이름을 응답하는 간단한 웹 서버다.


파드가 포함한 컨테이너에 연결할 수 있도록 서비스를 생성한다.


[root@k8s-master ~]# kubectl expose rc kubia --type=LoadBalancer --name kubia-http

service/kubia-http exposed


kubectl get services 명령어로 생성한 서비스 정보를 보자. 내가 테스트한 환경에서는 LoadBalancer 타입 서비스가 클러스터 IP로 10.101.195.144를 사용하고 있다.


[root@k8s-master ~]# kubectl get services

NAME         TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE

kubernetes   ClusterIP      10.96.0.1        <none>        443/TCP          3h22m

kubia-http   LoadBalancer   10.101.195.144   <pending>     8080:31701/TCP   15s


쿠버네티스 클러스터를 설치한 서버에서 이 클러스터 IP를 이용해서 8080 포트로 연결해보자. 다음과 비슷한 결과가 나오면 쿠버네티스가 정상적으로 동작하고 있는 것이다.


# curl 10.101.195.144:8080

You've hit kubia-ckh8w




  1. 엽이 2019.04.04 16:24

    저도 쿠버네티스 인 액션 책을 통해 공부하려고 주문하였는데 아직 오지를 않아서.. 쿠버네티스 관련하여 인터넷 글을 참고하던차에 여기글을 보고 기본적인 셋팅 및 서비스 테스트까지 성공적으로 해 볼 수 있었습니다. 감사합니다.

  2. 2019.06.25 15:16

    비밀댓글입니다

  3. 동방폐인 2019.07.16 16:23

    사이트 아직 살아 있구나...광균아... 요즘은 어떻게 사는지...?

    나도 이제 K8s 시작한다... 이것도 제대로 쓰려면 골치 아픈 거구낭...ㅠ

  4. 한만큼 2019.09.19 15:53 신고

    덕분에 잘 따라했습니다. 감사합니다. LoadBalancer 는 왜 설정해주는건지 궁금합니다.

  5. castinglife 2019.11.29 14:29

    # yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 설치시 제대로 되지 않는d아래와 같은 에러가 발생합니다.
    ==============================================================================================
    Loaded plugins: fastestmirror
    adding repo from: https://download.docker.com/linux/centos/docker-ce.repo
    grabbing file https://download.docker.com/linux/centos/docker-ce.repo to /etc/yum.repos.d/docker-ce.repo
    Could not fetch/save url https://download.docker.com/linux/centos/docker-ce.repo to file /etc/yum.repos.d/docker-ce.repo: [Errno 14] curl#60 - "Peer's Certificate has expired."

    rdate 패키지 설치 ( rdate가 없을 시 yum 으로 설치해준다 )
    # yum install -y rdate

    명령어를 통해 설치
    # rdate -s time.bora.net

    # date
    Thu Nov 28 23:58:06 EST 2019
    정상적으로 현재시간이 찍히는것을 확인할수 있다.

    # sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
    =============================================================================================
    Loaded plugins: fastestmirror
    adding repo from: https://download.docker.com/linux/centos/docker-ce.repo
    grabbing file https://download.docker.com/linux/centos/docker-ce.repo to /etc/yum.repos.d/docker-ce.repo
    repo saved to /etc/yum.repos.d/docker-ce.repo

    이제는 정상적으로 진행됨..^^
    =============================================================================================

  6. castinglife 2019.11.29 15:50


    ————————————————————————————————————
    # cat <<EOF > /etc/yum.repos.d/kubernetes.repo

    [kubernetes]

    name=Kubernetes

    baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64

    enabled=1

    gpgcheck=1

    repo_gpgcheck=1

    gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

    exclude=kube*

    EOF
    ————————————————————————————————————
    위의 설정을 사용하면 저장소를 못찾는 에러가 발생 합니다.

    아래의 설정을 사용하면 정상 설치 됩니다.

    ————————————————————————————————————
    # cat <<EOF > /etc/yum.repos.d/kubernetes.repo

    [kubernetes]

    name=Kubernetes

    baseurl = http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64

    enabled = 1

    gpgcheck = 0

    repo_gpgcheck = 0

    gpgkey = http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
    https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg

    exclude=kube*

    EOF
    ————————————————————————————————————

    설정후 설치하면 정상적으로 설치 됩니다.
    ——————————————————————————————————————————————————————————————————
    # yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
    Loaded plugins: fastestmirror
    Loading mirror speeds from cached hostfile
    * base: data.aonenetworks.kr
    * extras: data.aonenetworks.kr
    * updates: data.aonenetworks.kr
    base | 3.6 kB 00:00:00
    https://download.docker.com/linux/centos/7/x86_64/stable/repodata/repomd.xml: [Errno 14] curl#60 - "Peer's Certificate has expired."
    Trying other mirror.
    It was impossible to connect to the CentOS servers.
    This could mean a connectivity issue in your environment, such as the requirement to configure a proxy,
    or a transparent proxy that tampers with TLS security, or an incorrect system clock.
    You can try to solve this issue by using the instructions on https://wiki.centos.org/yum-errors
    If above article doesn't help to resolve this issue please use https://bugs.centos.org/.

    extras | 2.9 kB 00:00:00
    kubernetes | 1.4 kB 00:00:00
    updates | 2.9 kB 00:00:00
    kubernetes/primary | 59 kB 00:00:01
    kubernetes 430/430
    Resolving Dependencies
    --> Running transaction check
    ---> Package kubeadm.x86_64 0:1.16.3-0 will be installed
    --> Processing Dependency: kubernetes-cni >= 0.7.5 for package: kubeadm-1.16.3-0.x86_64
    --> Processing Dependency: cri-tools >= 1.13.0 for package: kubeadm-1.16.3-0.x86_64
    ---> Package kubectl.x86_64 0:1.16.3-0 will be installed
    ---> Package kubelet.x86_64 0:1.16.3-0 will be installed
    --> Processing Dependency: socat for package: kubelet-1.16.3-0.x86_64
    --> Processing Dependency: conntrack for package: kubelet-1.16.3-0.x86_64
    --> Running transaction check
    ---> Package conntrack-tools.x86_64 0:1.4.4-5.el7_7.2 will be installed
    --> Processing Dependency: libnetfilter_cttimeout.so.1(LIBNETFILTER_CTTIMEOUT_1.1)(64bit) for package: conntrack-tools-1.4.4-5.el7_7.2.x86_64
    --> Processing Dependency: libnetfilter_cttimeout.so.1(LIBNETFILTER_CTTIMEOUT_1.0)(64bit) for package: conntrack-tools-1.4.4-5.el7_7.2.x86_64
    --> Processing Dependency: libnetfilter_cthelper.so.0(LIBNETFILTER_CTHELPER_1.0)(64bit) for package: conntrack-tools-1.4.4-5.el7_7.2.x86_64
    --> Processing Dependency: libnetfilter_queue.so.1()(64bit) for package: conntrack-tools-1.4.4-5.el7_7.2.x86_64
    --> Processing Dependency: libnetfilter_cttimeout.so.1()(64bit) for package: conntrack-tools-1.4.4-5.el7_7.2.x86_64
    --> Processing Dependency: libnetfilter_cthelper.so.0()(64bit) for package: conntrack-tools-1.4.4-5.el7_7.2.x86_64
    ---> Package cri-tools.x86_64 0:1.13.0-0 will be installed
    ---> Package kubernetes-cni.x86_64 0:0.7.5-0 will be installed
    ---> Package socat.x86_64 0:1.7.3.2-2.el7 will be installed
    --> Running transaction check
    ---> Package libnetfilter_cthelper.x86_64 0:1.0.0-10.el7_7.1 will be installed
    ---> Package libnetfilter_cttimeout.x86_64 0:1.0.0-6.el7_7.1 will be installed
    ---> Package libnetfilter_queue.x86_64 0:1.0.2-2.el7_2 will be installed
    --> Finished Dependency Resolution

    Dependencies Resolved

    ==========================================================================================================================================================
    Installing:
    kubeadm x86_64 1.16.3-0 kubernetes 9.5 M
    kubectl x86_64 1.16.3-0 kubernetes 10 M
    kubelet x86_64 1.16.3-0 kubernetes 22 M
    Installing for dependencies:
    conntrack-tools x86_64 1.4.4-5.el7_7.2 updates 187 k
    cri-tools x86_64 1.13.0-0 kubernetes 5.1 M
    kubernetes-cni x86_64 0.7.5-0 kubernetes 10 M
    libnetfilter_cthelper x86_64 1.0.0-10.el7_7.1 updates 18 k
    libnetfilter_cttimeout x86_64 1.0.0-6.el7_7.1 updates 18 k
    libnetfilter_queue x86_64 1.0.2-2.el7_2 base 23 k
    socat x86_64 1.7.3.2-2.el7 base 290 k

    Transaction Summary
    ==========================================================================================================================================================
    Install 3 Packages (+7 Dependent packages)

    Total download size: 57 M
    Installed size: 262 M
    Downloading packages:
    (1/10): conntrack-tools-1.4.4-5.el7_7.2.x86_64.rpm | 187 kB 00:00:00
    (2/10): 14bfe6e75a9efc8eca3f638eb22c7e2ce759c67f95b43b16fae4ebabde1549f3-cri-tools-1.13.0-0.x86_64.rpm | 5.1 MB 00:00:01
    (3/10): fd6465355a85b8ddbc0b2e7cb073e3a40160c7c359576b86e9b8eca0a2d7805b-kubectl-1.16.3-0.x86_64.rpm | 10 MB 00:00:02
    (4/10): b45a63e77d36fc7e1ef84f1cd2f7b84bccf650c8248191a37d20c69564d8b8df-kubeadm-1.16.3-0.x86_64.rpm | 9.5 MB 00:00:04
    (5/10): libnetfilter_cthelper-1.0.0-10.el7_7.1.x86_64.rpm | 18 kB 00:00:00
    (6/10): libnetfilter_cttimeout-1.0.0-6.el7_7.1.x86_64.rpm | 18 kB 00:00:00
    (7/10): socat-1.7.3.2-2.el7.x86_64.rpm | 290 kB 00:00:00
    (8/10): libnetfilter_queue-1.0.2-2.el7_2.x86_64.rpm | 23 kB 00:00:00
    (9/10): 8a0e2b605c7a616d7cb72c25c9058b2327e41d869046c7c6cb3930f10a3dc012-kubelet-1.16.3-0.x86_64.rpm | 22 MB 00:00:04
    (10/10): 548a0dcd865c16a50980420ddfa5fbccb8b59621179798e6dc905c9bf8af3b34-kubernetes-cni-0.7.5-0.x86_64.rpm | 10 MB 00:00:04
    ----------------------------------------------------------------------------------------------------------------------------------------------------------
    Total 6.2 MB/s | 57 MB 00:00:09
    Running transaction check
    Running transaction test
    Transaction test succeeded
    Running transaction
    Installing : libnetfilter_cttimeout-1.0.0-6.el7_7.1.x86_64 1/10
    Installing : socat-1.7.3.2-2.el7.x86_64 2/10
    Installing : kubectl-1.16.3-0.x86_64 3/10
    Installing : cri-tools-1.13.0-0.x86_64 4/10
    Installing : libnetfilter_queue-1.0.2-2.el7_2.x86_64 5/10
    Installing : libnetfilter_cthelper-1.0.0-10.el7_7.1.x86_64 6/10
    Installing : conntrack-tools-1.4.4-5.el7_7.2.x86_64 7/10
    Installing : kubernetes-cni-0.7.5-0.x86_64 8/10
    Installing : kubelet-1.16.3-0.x86_64 9/10
    Installing : kubeadm-1.16.3-0.x86_64 10/10
    Verifying : kubeadm-1.16.3-0.x86_64 1/10
    Verifying : libnetfilter_cthelper-1.0.0-10.el7_7.1.x86_64 2/10
    Verifying : conntrack-tools-1.4.4-5.el7_7.2.x86_64 3/10
    Verifying : kubelet-1.16.3-0.x86_64 4/10
    Verifying : libnetfilter_queue-1.0.2-2.el7_2.x86_64 5/10
    Verifying : cri-tools-1.13.0-0.x86_64 6/10
    Verifying : kubectl-1.16.3-0.x86_64 7/10
    Verifying : kubernetes-cni-0.7.5-0.x86_64 8/10
    Verifying : socat-1.7.3.2-2.el7.x86_64 9/10
    Verifying : libnetfilter_cttimeout-1.0.0-6.el7_7.1.x86_64 10/10

    Installed:
    kubeadm.x86_64 0:1.16.3-0 kubectl.x86_64 0:1.16.3-0 kubelet.x86_64 0:1.16.3-0

    Dependency Installed:
    conntrack-tools.x86_64 0:1.4.4-5.el7_7.2 cri-tools.x86_64 0:1.13.0-0 kubernetes-cni.x86_64 0:0.7.5-0
    libnetfilter_cthelper.x86_64 0:1.0.0-10.el7_7.1 libnetfilter_cttimeout.x86_64 0:1.0.0-6.el7_7.1 libnetfilter_queue.x86_64 0:1.0.2-2.el7_2
    socat.x86_64 0:1.7.3.2-2.el7

    Complete!

    ——————————————————————————————————————————————————————————————————

최근에 사용하는 프로필이 dev, prod, local, test 4개가 존재하는 스프링 부트 어플리케이션을 개발하고 있다. 로컬에서 'mvn spring-boot:run' 명령어를 실행하면 local 프로필을 사용해서 부트 앱을 실행하고 싶었다. src/main/resources 폴더에 application-prod.properties, application-dev.properties, application-local.properties 파일이 함께 존재해서 src/main/resources의 application.properties 파일에 spring.profiles.active=local 설정을 줄 수 없었다.


'mvn spring-boot:run -Dspring-boot.run.profiles=local'와 같이 로컬에서 실행할 때 마다 프로필을 지정하려니까 귀찮았다. 그래서 프로필을 선택하지 않은 경우 기본으로 local 프로필을 활성화하는 설정을 추가했다.


먼저 EnvironmentPostProcessor 인터페이스를 구현한 클래스를 작성한다.


public class ProfileResolverEnvironmentPostProcessor implements EnvironmentPostProcessor {


    @Override

    public void postProcessEnvironment(ConfigurableEnvironment environment, 

                                                   SpringApplication application) {

        boolean isSomeProfileActive = 

                environment.acceptsProfiles(Profiles.of("prod", "dev", "test", "local"));


        if (!isSomeProfileActive) {

            environment.addActiveProfile("local");

            Resource path = new ClassPathResource("application-local.properties");

            if (path.exists()) {

                try {

                    environment.getPropertySources().addLast(

                            new PropertiesPropertySourceLoader().load("application-local", path).get(0));

                } catch (IOException e) {

                    throw new IllegalStateException(e);

                }

            }

        } else {

            log.info("Some of [prod, dev, test, local] is active: " + environment.getActiveProfiles());

        }

    }

}


이 코드는 ConfigurableEnvironment#acceptsProfiles() 메서드를 이용해서 "prod", "dev", "test", "local" 프로필 중 하나라도 활성화되어 있는지 검사한다. 활성화되어 있지 않으면 활성 프로필을 "local"을 추가하고, 사용할 프로퍼티 소스로 "application-local" 프로퍼티 파일을 추가한다.


다음 할 일은 META-INF/spring.factories 파일에 다음 설정을 추가하는 것이다.


org.springframework.boot.env.EnvironmentPostProcessor=\

demo.ProfileResolverEnvironmentPostProcessor


특정 프로필을 선택하지 않고 부트 어플리케이션을 실행하면 local 프로필이 활성화되는 것을 확인할 수 있다.

스프링 스케줄러를 이용해서 cron 설정을 런타임에 변경하는 방법을 살펴본다.


1. TaskScheduler 설정


먼저 TaskScheduler를 설정한다.


@Configuration

public class SchedulingConfiguration {


    @Bean

    public ThreadPoolTaskScheduler schedulerExecutor() {

        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();

        taskScheduler.setPoolSize(4);

        taskScheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

        return taskScheduler;

    }


}


스프링 부트를 사용한다면 부트가 알아서 TaskScheduler를 만들어준다.


2. cron을 사용해서 작업을 스케줄링하는 코드 작성


다음은 cron을 이용해서 스케줄링하는 코드를 작성한다. 예제는 다음과 같다.


@Service

public class SchedulerService {

    private TaskScheduler scheduler;

    private String cron = "*/2 * * * * *";

    private ScheduledFuture<?> future;


    public SchedulerService(TaskScheduler scheduler) {

        this.scheduler = scheduler;

    }


    public void start() {

        ScheduledFuture<?> future = this.scheduler.schedule(() -> {

                    System.out.println("run at " + LocalDateTime.now());

                },

                new CronTrigger(cron));

        this.future = future;

    }


    public void changeCron(String cron) {

        if (future != null) future.cancel(true);

        this.future = null;

        this.cron = cron;

        this.start();

    }

}


scheduler.schedule()은 스케줄링을 취소할 수 있는 ScheduledFuture를 리턴한다. 이 ScheduledFuture를 이용해서 스케줄을 변경할 때 이전 스케줄을 취소하고 새 스케줄을 등록하면 된다. 위 코드에서 changeCron() 메서드는 앞서 생성한 스케줄이 있다면 future.cancel()을 이용해서 스케줄을 취소한다.


3. 스케줄 런타임 변경 확인


테스트 코드를 이용해서 실제 스케줄이 런타임에 바뀌는지 확인해보자.


@RunWith(SpringRunner.class)

@SpringBootTest

public class SchedulerServiceTest {

    @Autowired

    private SchedulerService schedulerService;


    @Test

    public void changeCron() throws InterruptedException {

        schedulerService.start();

        Thread.sleep(10000);

        schedulerService.changeCron("*/3 * * * * *");

        Thread.sleep(20000);

    }

}


SchedulerService의 최초 cron 설정은 "2/* * * * * *"이므로 매 2초마다 작업을 실행한다. 위 코드는 스케줄링을 시작한 뒤에 10초간 쉬고 그 다음에 매 3초마다 작업을 실행하도록 cron 설정을 변경한다. 그리고 20초 동안 쉰다. 실행 결과는 다음과 같다.


run at 2018-12-20T23:03:02.003

run at 2018-12-20T23:03:04.002

run at 2018-12-20T23:03:06.001

run at 2018-12-20T23:03:08.001

run at 2018-12-20T23:03:10.002

run at 2018-12-20T23:03:12.002

run at 2018-12-20T23:03:15.002

run at 2018-12-20T23:03:18.003

run at 2018-12-20T23:03:21.001

run at 2018-12-20T23:03:24.001

run at 2018-12-20T23:03:27.002

run at 2018-12-20T23:03:30.001


위 결과를 보면 2초 마다 실행하다가 changeCron()을 실행한 뒤부터는 3초 마다 실행하는 것을 확인할 수 있다.


예제 코드는 https://github.com/madvirus/spring-scheduler-cron-change 에서 확인할 수 있다.

클라우드 서버에 실수로 용량이 큰 이미지 파일을 올리면 과도한 트래픽 발생으로 높은 비용을 지불할 수도 있다. 이런 상황을 방지하는 방법 중 하나는 아파치 웹 서버 설정에서 응답 파일의 크기를 제한하는 것이다. 아파치 웹 서버에서는 RewirteCond에서 filesize() 식을 사용해서 특정 크기보다 큰 파일에 대한 접근을 거부할 수 있다. 다음은 <Directory> 설정은 1 MB(1048576 바이트) 큰 파일에 접근할 때 403 상태 코드를 응답하도록 설정한 예이다.


<Directory /var/www/html/images/>

  RewriteEngine On

  RewriteCond expr "filesize('%{REQUEST_FILENAME}') -gt 1048576"

  RewriteRule .* - [F]

</Directory>


참고로 filesize()를 이용한 설정은 아파치 2.4부터 지원한다.

다소 동접이 발생하는 간단한 TCP 서버를 구현할 기술을 찾다가 리액터 네티(Reactor Netty)를 알게 되었다. 리액터 네티를 이용하면 네티를 기반으로 한 네트워크 프로그램을 리액터 API로 만들 수 있다. 리액터 네티를 사용하면 네티를 직접 사용하는 것보다 간결한 코드로 비동기 네트워크 프로그램을 만들 수 있는 이점이 있다.


다음은 리액터 네티(Reactor Netty)의 주요 특징이다.

  • 네티 기반
  • 리액터 API 사용
  • 논블로킹 TCP, UDP, HTTP 클라이언트/서버

이 글에서는 리액터 네티를 이용해서 간단한 소켓 서버를 만들어 보겠다.

TcpServer를 이용한 소켓 서버 만들기

리액터 네티는 TcpServer 클래스를 제공한다. 이 클래스를 이용해서 비교적 간단하게 비동기 소켓 서버를 구현할 수 있다. 이 글에서는 간단한 에코 서버를 만들어 본다. 만들 기능은 다음과 같다.

  • 클라이언트가 한 줄을 입력하면 "echo: 입력한 줄\r\n"으로 응답한다.
  • 클라이언트가 exit를 입력하면 클라이언트와 연결을 끊는다.
  • 클라이언트가 SHUTDOWN을 입력하면 서버를 종료한다.
  • 10초 이내에 클라이언트로부터 입력이 없으면 연결을 종료한다.
리액터 네티를 사용하기 위한 메이븐 설정은 다음과 같다.

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.projectreactor</groupId>
                <artifactId>reactor-bom</artifactId>
                <version>Californium-SR3</version> <!-- 리액터 네티 0.8.3에 대응 -->
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>io.projectreactor.netty</groupId>
            <artifactId>reactor-netty</artifactId>
        </dependency>

        <dependency>
            <groupId>io.projectreactor.addons</groupId>
            <artifactId>reactor-logback</artifactId>
        </dependency>
    </dependencies>

다음 코드는 리액터 네티로 만든 에코 서버의 전체 코드이다.

package demo;

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.LineBasedFrameDecoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import reactor.core.publisher.Mono;
import reactor.netty.DisposableServer;
import reactor.netty.tcp.TcpServer;

import java.util.concurrent.CountDownLatch;

public class EchoServer {
    private static Logger log = LoggerFactory.getLogger(EchoServer.class);

    public static void main(String[] args) {
        CountDownLatch latch = new CountDownLatch(1);
        DisposableServer server = TcpServer.create()
                .port(9999) // 서버가 사용할 포트
                .doOnConnection(conn -> { // 클라이언트 연결시 호출
                    // conn: reactor.netty.Connection
                    conn.addHandler(new LineBasedFrameDecoder(1024));
                    conn.addHandler(new ChannelHandlerAdapter() {
                        @Override
                        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
                            log.info("client added");
                        }

                        @Override
                        public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
                            log.info("client removed");
                        }

                        @Override
                        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
                                       throws Exception {
                            log.warn("exception {}", cause.toString());
                            ctx.close();
                        }
                    });
                    conn.onReadIdle(10_000, () -> {
                        log.warn("client read timeout");
                        conn.dispose();
                    });
                })
                .handle((in, out) -> // 연결된 커넥션에 대한 IN/OUT 처리
                        // reactor.netty (NettyInbound, NettyOutbound)
                        in.receive() // 데이터 읽기 선언, ByteBufFlux 리턴
                          .asString()  // 문자열로 변환 선언, Flux<String> 리턴
                          .flatMap(msg -> {
                                      log.debug("doOnNext: [{}]", msg);
                                      if (msg.equals("exit")) {
                                          return out.withConnection(conn -> conn.dispose());
                                      } else if (msg.equals("SHUTDOWN")) {
                                          latch.countDown();
                                          return out;
                                      } else {
                                          return out.sendString(Mono.just("echo: " + msg + "\r\n"));
                                      }
                                  }
                          )
                )
                .bind() // Mono<DisposableServer> 리턴
                .block();

        try {
            latch.await();
        } catch (InterruptedException e) {
        }
        log.info("dispose server");
        server.disposeNow(); // 서버 종료
    }
}


먼저 전체 코드 구조를 살펴보자.

DisposableServer server = TcpServer.create()
        .port(9999) // 포트 지정
        .doOnConnection(conn -> { // 클라이언트 연결시 호출 코드
            ...
        })
        .handle((in, out) -> // 데이터 입출력 처리 코드
            ...
        )
        .bind() // 서버 실행에 사용할 Mono<DisposableServer>
        .block(); // 서버 실행 및 DisposableServer 리턴

...(서버 사용)

// 서버 중지
server.disposeNow();

전체 코드 구조는 다음과 같다.
  • TcpServer.create()로 TcpServer 준비
  • port()로 사용할 포트 포트
  • doOnConnection() 메서드로 클라이언트 연결시 실행할 함수 설정
    • 이 함수에서 커넥션에 ChannelHandler를 등록하는 것과 같은 작업 수행
  • handle() 메서드로 클라이언트와 데이터를 주고 받는 함수 설정
  • bind() 메서드로 서버 연결에 사용할 Mono<DisposableServer> 생성
  • bind()가 리턴한 Mono의 block()을 호출해서 서버 실행하고 DisposableServer 리턴
서버가 정상적으로 구동되면 block() 메서드는 구동중인 DisposableServer를 리턴한다. DisposableServer의 disposeNow() 메서드는 서버를 중지할 때 사용한다. 이 외에도 서버 중지에 사용되는 몇 가지 dispose로 시작하는 메서드를 제공한다.

doOnConnection()으로 커넥션 초기화

doOnConnection() 메서드의 파라미터는 다음 함수형 타입이다.
  • Consumer<? super Connection>
reactor.netty.Connection 타입은 인터페이스로 네티의 ChannelHandler 등록과 몇 가지 이벤트 연동 기능을 제공한다. 예제 코드의 doOnConnection 설정 부분을 다시 보자.

.doOnConnection(conn -> { // 클라이언트 연결시 호출
    conn.addHandler(new LineBasedFrameDecoder(1024));
    conn.addHandler(new ChannelHandlerAdapter() {
        @Override
        public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
            log.info("client added");
        }
        ...
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
        throws Exception {
            log.warn("exception {}", cause.toString());
            ctx.close();
        }
    });
    conn.onReadIdle(10_000, () -> {
        log.warn("client read timeout");
        conn.dispose();
    });

})

Connection#addHandler()는 네티의 ChannelHandler를 등록한다. 이 외에 addHandlerFirst(), addHandlerLast() 메서드를 제공한다. 이 메서드를 이용해서 필요한 네티 코덱을 등록하면 된다. 예제 코드에서는 한 줄씩 데이터를 읽어오는 LineBasedFrameDecoder를 등록했고 클라이언트 연결 이벤트에 따라 로그를 출력하기 위해 임의 ChannelHandlerAdapter 객체를 등록했다.

Connection#onReadIdle() 메서드는 첫 번째 인자로 지정한 시간(밀리초) 동안 데이터 읽기가 없으면 두 번째 인자로 전달받은 코드를 실행한다. 위 코드는 10초 동안 데이터 읽기가 없으면 연결을 종료한다. 비슷하게 onWriteIdle() 메서드는 지정한 시간 동안 쓰기가 없으면 코드를 실행한다.

handle() 메서드로 데이터 입출력 처리

데이터 송수신과 관련된 코드는 handle() 메서드로 지정한다. handle() 메서드가 전달 받는 함수형 타입은 다음과 같다.

BiFunction<? super NettyInbound, ? super NettyOutbound, ? extends Publisher<Void>>

이 함수는 NettyInbound와 NettyOutbound를 인자로 갖고 Publisher<Void>나 그 하위 타입을 리턴한다. 예제 코드의 handle() 메서드를 다시 보자.

.handle((in, out) -> // 연결된 커넥션에 대한 IN/OUT 처리
        // (NettyInbound, NettyOutbound)
        in.receive() // 데이터 읽기 선언, ByteBufFlux 리턴
          .asString()  // 문자열로 변환 선언, Flux<String> 리턴
          .flatMap(msg -> {
                      log.debug("doOnNext: [{}]", msg);
                      if (msg.equals("exit")) {
                          return out.withConnection(conn -> conn.dispose());
                      } else if (msg.equals("SHUTDOWN")) {
                          latch.countDown();
                          return out;
                      } else {
                          return out.sendString(Mono.just("echo: " + msg + "\r\n"));
                      }
                  }
          )
)


위 코드를 요약하면 다음과 같다.

  • NettyInbound#receive()는 데이터 수신을 위한 ByteBufFlux를 리턴
  • ByteBufFlux#asString()은 데이터를 문자열로 수신 처리
  • flatMap을 이용해서 수신한 메시지 처리

flatMap은 수신한 데이터를 이용해서 알맞은 처리를 한다. 클라이언트에 데이터를 전송할 때에는  NettyOutbound를 이용한다. NettyOutbound#sendString() 메서드를 이용하면 문자열 데이터를 클라이언트에 전송한다. NettyOutbound#sendString()의 파라미터는 Publisher<? extends String> 타입이기 때문에 위 코드에 Mono.just()를 이용했다.


Connection이 필요하면 NettyOutbound#withConnection() 메서드를 사용한다. 위 코드에서는 클라이언트가 "exit"를 전송하면 연결을 끊기 위해 이 메서드를 사용했다.


ByteBufFlux#asString() 메서드는 기본 캐릭터셋을 사용한다. 다른 캐릭터셋을 사용하고 싶다면 asString(Charset) 메서드를 사용한다. 비슷하게 NettyOutbound#sendString() 메서드도 기본 캐릭터셋을 사용하므로 다른 캐릭터셋을 사용하려면 NettyOutbound#sendString(Publisher, Charset) 메서드를 사용한다.


예제 실행

EchoServer를 실행해보자. 로그백을 사용했다면 아래와 비슷한 메시지가 출력되면서 서버가 구동된다.


08:49:10.522 [reactor-tcp-nio-1] DEBUG reactor.netty.tcp.TcpServer - [id: 0x1fb82e53, L:/127.0.0.1:9999] Bound new server


telnet을 이용해서 에코가 제대로 동작하는지 확인해본다. 클라이언트가 전송한 데이터를 굵은 글씨로 표시했고 서버가 응답한 데이터를 파란색으로 표시했다.


$ telnet localhost 9999

Trying 127.0.0.1...

Connected to localhost.

Escape character is '^]'.

124124

echo: 124124

wefwef

echo: wefwef

exit

Connection closed by foreign host.

$


위 과정에서 서버에 출력되는 로그는 다음과 같다(리액터 네티가 출력하는 로그는 생략했다.)


08:50:40.187 [reactor-tcp-nio-5] INFO  demo.EchoServer - client added

08:50:37.374 [reactor-tcp-nio-4] INFO  demo.EchoServer - doOnNext: [124124]

08:50:44.506 [reactor-tcp-nio-4] INFO  demo.EchoServer - doOnNext: [wefwef]

08:50:46.218 [reactor-tcp-nio-4] INFO  demo.EchoServer - doOnNext: [exit]

08:50:46.221 [reactor-tcp-nio-4] INFO  demo.EchoServer - client removed


Connection#onReadIdle()을 이용해서 읽기 타임아웃을 10초로 설정했는데 실제로 서버 접속 후 10초 동안 데이터를 전송하지 않으면 연결이 끊기는 것을 확인할 수 있다.


08:56:23.358 [reactor-tcp-nio-2] WARN  demo.EchoServer - client read timeout

08:56:23.360 [reactor-tcp-nio-2] INFO  demo.EchoServer - client removed


마지막으로 SHUTDOWN 명령어를 전송해 보자. 그러면 서버가 종료되는 것도 확인할 수 있을 것이다.


08:57:46.372 [reactor-tcp-nio-3] INFO  demo.EchoServer - doOnNext: [SHUTDOWN]

08:57:46.373 [main] INFO  demo.EchoServer - dispose server


특정 시간 동안 실행 횟수를 제한하기 위한 라이브러를 검색해서 아래 3가지 정도를 찾았다.

이 글에서는 각 라이브러리의 사용법을 간단하게 살펴본다.

Guava RateLimiter

Guava에 포함된 RateLimiter를 사용하면 초당 실행 횟수를 제한할 수 있다. 이 클래스를 사용하려면 다음 의존을 추가한다.

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>26.0-jre</version>
</dependency>

사용 방법은 다음과 같다.

private RateLimiter limiter = RateLimiter.create(4.0); // 초당 4개

public void someLimit() {
    if (limiter.tryAcquire()) { // 1개 사용 요청
        // 초과하지 않음
        ... 코드1 // 초당 4번까지 실행 가능

    } else {
        // 제한 초과

    }
}

RateLimiter.create() 메서드는 초당 몇 개를 허용할지를 인수로 받는다. 위 예의 경우 4.0을 값으로 주었는데 이는 초당 4개를 허용함을 뜻한다. 이 값을 0.2로 주면 초당 0.4개를 허용하므로 5초당 1개를 허용한다.


실행 횟수를 초과했는지 검사할 때 tryAcquire() 메서드를 사용한다. 이 메서드는 허용하는 횟수를 초과하지 않았으면 true를 리턴하고 초과했으면 false를 리턴한다. 따라서 위 코드는 someLimit() 메서드의 '코드1'을 초당 4번까지 실행한다. 만약 1초 이내에 5번을 실행하면 그 중 한 번은 tryAcquire() 메서드가 false를 리턴한다.


RateLimiter는 실행 가능 시점을 분배하는 방식을 사용한다. 예를 들어 다음과 같이 초당 실행 가능한 횟수를 5.0으로 지정하고 0.1초마다 tryAcquire() 메서드를 실행한다고 하자.


RateLimiter limiter = RateLimiter.create(5.0);


Timer timer = new Timer(true);


timer.scheduleAtFixedRate(new TimerTask() {

    @Override

    public void run() {

        if (limiter.tryAcquire()) {

            log.info("!! OK");

        } else {

            log.warn("XX");

        }

    }

}, 0, 100); // 0.1초마다 실행


Thread.sleep(1500);


위 코드를 실행한 결과는 다음과 같다. 이 결과를 보면 "!! OK"와 "XX"가 번갈아 출력된 것을 알 수 있다. 즉 초당 5.0으로 횟수를 제한했을 때 1초에 10번 tryAcquire()를 실행하면 연속해서 5번 실행 가능한 게 아니고 1초에 5번 실행 가능한 시점이 분산되는 것을 알 수 있다.

17:27:39.503 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:39.596 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:39.695 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:39.797 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:39.898 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:39.998 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:40.098 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:40.197 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:40.297 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:40.396 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:40.498 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:40.594 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:40.695 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:40.795 [Timer-0] WARN guava.RateLimiterTest - XX
17:27:40.897 [Timer-0] INFO guava.RateLimiterTest - !! OK
17:27:40.997 [Timer-0] WARN guava.RateLimiterTest - XX


[노트]

RateLimiter의 내부 구현은 1초 동안 사용하지 않은 개수를 누적한다. 예를 들어 RateLimiter.create(10)으로 만든 RateLimiter를 1초 동안 사용하지 않았다면 5개가 누적되어 이후 1초 동안은 10개를 사용할 수 있다.


RateLimitJ

RateLimitJ는 Redis, Hazelcast를 이용해서 시간 당 실행 횟수를 제한할 수 있다. 메모리를 이용한 구현도 지원하므로 Redis나 Hazelcast가 없어도 사용할 수 있다. 이 글에서는 인메모리 구현의 사용법을 살펴본다. 인메모리 구현을 사용하려면 다음 의존을 추가한다. Redis를 이용한 구현을 사용하는 방법은 https://github.com/mokies/ratelimitj 사이트를 참고한다.


<dependency>

    <groupId>es.moki.ratelimitj</groupId>

    <artifactId>ratelimitj-inmemory</artifactId>

    <version>0.5.0</version>

</dependency>


RateLimitJ를 이용한 실행 횟수 제한 방법은 다음과 같다.


// 1분에 10개 제한

RequestLimitRule limitRule = RequestLimitRule.of(Duration.ofMinutes(1), 10);

RequestRateLimiter rateLimiter =

        new InMemorySlidingWindowRequestRateLimiter(limitRule);


if (rateLimiter.overLimitWhenIncremented("key")) {

    // 제한 초과


} else {

    // 초과하지 않음


}


RequestLimitRule은 제한 규칙을 적용한다. RequestLimitRule.of() 메서드를 이용해서 제한 규칙을 생성하는데 첫 번째 파라미터는 시간 범위이고 두 번째 파라미터는 제한 횟수이다. 위 코드는 1분 동안 10으로 제한하는 규칙을 생성한다.


이 규칙을 사용해서 InMemorySlidingWindowRequestRateLimiter 객체를 생성하면 사용할 준비가 끝난다.


RequestRateLimiter#overLimitWhenIncremented(key) 메서드는 특정 시간 동안 지정한 횟수를 초과했는지 검사한다. 초과했으면 true를 리턴하고 초과하지 않았으면 false를 리턴한다. 따라서 이 메서드가 false를 리턴할 때 기능을 실행하면 된다.


overLimitWhenIncremented() 메서드는 인수로 key를 받는다. 이 key 별로 규칙을 적용한다. 예를 들어 URI 마다 실행 횟수를 제한하고 싶다면 다음과 같이 key로 URI를 사용하면 된다.


// 각 URI마다 실행 횟수 제한

if (rateLimiter.overLimitWhenIncremented(request.getRequestURI())) {

    // 해당 URI에 대한 제한 초과


} else {

    // 해당 URI에 대한 접근 허용


}


Guava의 RateLimiter와 달리 RateLimitJ는 지정한 횟수에 다다를 때까지 실행을 허용하고 그 이후로는 시간이 지날 때까지 실행을 허용하지 않는다. 예를 들어 다음 코드를 보자.


RequestLimitRule limitRule = RequestLimitRule.of(Duration.ofSeconds(1), 5);

RequestRateLimiter rateLimiter =

        new InMemorySlidingWindowRequestRateLimiter(limitRule);


Timer timer = new Timer(true);


timer.scheduleAtFixedRate(new TimerTask() {

    @Override

    public void run() {

        if (rateLimiter.overLimitWhenIncremented("key")) {

            log.warn("XX"); // 제한 초과로 실행하지 않음

        } else {

            log.info("!! OK"); // 제한을 초과하지 않아 실행함

        }

    }

}, 0, 100);


Thread.sleep(1500);


이 코드는 1초 당 5개로 제한하는 RequestRateLimiter를 사용하고 0.1초마다 한 번씩 기능을 실행하고 있다. 이 코드를 실행하면 다음과 같이 처음 5개 요청을 실행하고 그 이후 1초가 지날 때까지 5개 요청은 제한 초과로 실행하지 않은 것을 알 수 있다.


17:46:38.061 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:38.130 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:38.230 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:38.330 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:38.430 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:38.531 [Timer-0] WARN ratelimitj.RateLimitJTest - XX

17:46:38.632 [Timer-0] WARN ratelimitj.RateLimitJTest - XX

17:46:38.733 [Timer-0] WARN ratelimitj.RateLimitJTest - XX

17:46:38.833 [Timer-0] WARN ratelimitj.RateLimitJTest - XX

17:46:38.931 [Timer-0] WARN ratelimitj.RateLimitJTest - XX

17:46:39.033 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:39.134 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:39.235 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:39.330 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK

17:46:39.432 [Timer-0] INFO ratelimitj.RateLimitJTest - !! OK


Bucket4j

Bucket4j는 hazelcast, infinispan을 이용한 구현 외에 인메모리 구현을 지원한다. 이 글에서는 인모메리 구현을 이용한 횟수 제한에 대해 살펴본다. 다른 구현에 대한 내용은 https://github.com/vladimir-bukhtoyarov/bucket4j 문서를 참고한다.


인메모리 구현을 사용하려면 다음 의존을 추가한다.


<dependency>

    <groupId>com.github.vladimir-bukhtoyarov</groupId>

    <artifactId>bucket4j-core</artifactId>

    <version>4.0.1</version>

</dependency>


사용법은 다음과 같다.


// 1초에 5개 사용 제한

Bandwidth limit = Bandwidth.simple(5, Duration.ofSeconds(1));

// 버킷 생성

Bucket bucket = Bucket4j.builder().addLimit(limit).build();


if (bucket.tryConsume(1)) { // 1개 사용 요청

    // 초과하지 않음


} else {

    // 제한 초과

    

}


Bandwith는 지정한 시간 동안 제한할 개수를 지정한다. 위 코드는 1초 동안 5개를 허용하는 Bandwith를 생성한다. 이 Bandwith를 이용해서 Bucket을 생성한다. Bucket#tryConsume() 메서드는 사용할 개수를 인수로 받으며, 사용 가능할 경우 true를 리턴하고 사용 가능하지 않으면 false를 리턴한다.



[노트]

Bucket4j는 다중 Bandwidth를 지원한다. 또한 사용 가능 개수를 시간이 흘러감에 따라 점진적으로(greedy) 채우는 방식과 시간 간격마다 채우는 방식을 지원한다. 이에 대한 내용은 Bucket4j 문서를 참고한다.




이 글은 DevOps Handbook 책을 읽고 몇 가지 핵심 실천법을 정리한 것이다. (원서 링크, 번역서 링크)


*주의: 요약 글에 오류/오역이 존재할 수 있고 더 중요한 내용을 누락했을 수도 있으니 애매한 부분은 반드시 원문을 참고하기 바란다.


데브옵스 시작하기

밸류스트림 선택

  • 데브옵스 전환을 시도할 밸류 스트림은 신중히 선택할 것: 성공해야 확대 기회 생김
  • 동조 잘하고 혁신적인 그룹과 시작하기: 보수적인 그룹은 처음부터 설득하지 말고 충분히 성공한 뒤에 해결
밸류 스트림 이해, 팀 구성, 계획
  • 밸류 스트림 맵 작성: 모든 구성원 식별, 빠른 가치 제공을 위협하는 영역 이해
  • 개선할 메트릭을 선택하고 목표와 일정 결정
  • 전용 전환 팀 구성
  • 목표를 합의하고 공유: 측정 가능한 목표, 6개월~2년 사이의 명확한 기한, 어렵지만 달성 가능한 목표, 조직과 고객에 가치 있음, 책임자가 목표에 동의, 목표를 조직 전체 공유
  • 개선 계획은 짧게: 2-3주 안에 측정 가능한 개선이나 이용 가능한 데이터를 만들어야 함, 빠른 개선으로 일상 업무에서 차이를 만들어 내고, 빠른 증명으로 프로젝트를 유지
  • 모두가 작업 상태를 알 수 있도록 최신 상태 공개
조직 구성
  • 시장 지향 팀 구성
  • 밸류 스트림에 관여하는 모두가 고객 목표와 조직 목표 공유
  • 제너럴리스트: 배움을 장려, 호기심/용기/솔직함을 가진 사람 채용
  • 프로젝트가 아닌 서비스와 제품에 투자
  • 콘웨이 법칙에 따라 팀 경계 설계
  • 팀을 작게 유지
운영을 개발 환경에 통합
  • 운영 역량을 개발 팀에 통합: 운영과 개발의 효율과 생산성을 높이고 시장 지향 결과를 더 잘 만들어 낼 수 있도록 함
  • 운영도 개발 활동에 참여: 운영 엔지니어를 서비스 팀에 포함시키거나 운영 담당자를 서비스 팀에 할당해서 제품 관련 작업을 운영 계획에 반영하고 제품 팀에 운영 지식 전파
  • 제품과 관련된 운영 작업을 공유 칸반 보드에 공개: 운영도 밸류 스트림의 일부

흐름(Flow) 개선

배포 파이프라인 기반

  • 필요할 때 개발, 테스트, 제품 환경을 생성할 수 있어야 함: 모든 환경을 만들 수 있는 빌드 장치, 환경 구성에 필요한 것을 체계화/자동화, 이를 통해 일관된 환경 생성 프로세스 구축, 수작업 감소
  • 단일 리포지토리: 환경도 버전 컨트롤로 관리, 빠르게 롤백할 수 있는 방법 제공
  • 반복가능한 환경 구축 시스템으로 인프라도 빠르게 재구축할 수 있게 함
  • 조기에 환경을 코드와 통합하고 배포를 연습해서 릴리즈와 관련된 위험을 줄임
빠르고 신뢰할 수 있는 자동화된 테스트
  • 자동화된 테스트 스위트 작성: 배포 파이프라인으로 커밋한 모든 코드를 자동으로 빌드하고 테스트
  • 자동화된 빌드/테스트 프로세스를 실행하는 전용 환경 구축
  • UAT, 보안 테스트 환경을 셀프 서비스로 생성 가능
  • 테스트 커버리지를 이용해서 테스트 작성 유도
  • 성능 테스트, 비기능 요구사항 테스트를 배포 파이프라인에 통합
  • 배포 파이프라인이 깨지면 작업을 멈추고 즉시 해결: 문제 해결에 조기에 발견할 수 있는 테스트 케이스를 추가
지속적 통합(CI)
  • 작은 배치로 개발
  • 트렁크에 자주 커밋, 일일 커밋
저위험 출시
  • 배포 프로세스 단순화, 자동화: 소요 시간이 긴 단계를 제거하기 위해 아키텍처 개선, 소요 시간과 이관 횟수를 줄이기 위한 노력
  • 모든 환경에 대해 동일한 방법으로 배포
  • 자동화된 배포 셀프 서비스로 개발자가 직접 배포: 자동화된 테스트, 자동화된 배포, 코드 리뷰 등 위험 감소 장치 필요
  • CI로 배포 가능 패키지 생성, 제품 환경 준비 조회, 특정 버전 패키지를 배포할 수 있는 버튼, 감사 기록, 스모크 테스트 실행, 배포 성공 여부를 빠르게 피드백을 제공하는 배포 자동화
  • 배포와 릴리즈 분리: 블루-그린 배포, 카나리아 릴리즈, 기능 토글, 다크 론치 등으로 릴리즈 위험 감소
  • CD(Delivery): 트렁크에서 작은 크기로 작업 또는 짧은 피처 브랜치, 트렁크는 항상 릴리즈 가능 상태로 유지, 업무 시간에 필요할 때 푸시 버튼으로 릴리즈 가능
  • CD(Deployment): Delivery + 정기적으로 빌드를 제품에 배포


피드백

문제 확인과 해결 위한 텔레메트리

  • 중앙 집중화된 텔레메트리 인프라
  • 어플리케이션 메트릭을 충분하게 생성
  • 텔레메트리를 사용해서 문제 해결에 과학적으로 접근
  • 어플리케이션 메트릭, 비즈니스 메트릭, 인프라 메트릭을 함께 표시
  • 유지보수, 백업, 배포 등 배포/운영 활동도 메트릭에 표시

예측을 더 잘하고 목표를 달성하기 위한 텔레메트리 분석

  • 평균, 표준 편차, 비정상 탐지 기법(데이터 스무딩, 콜모고로프-스마르노프 검정 등)을 사용해서 잠재적인 문제 발견
  • 장애를 예측할 수 있는 메트릭을 찾아 모니터링 시스템에 추가
안전한 배포를 위한 피드백
  • 기능이 정상임을 확인할 수 있는 충분한 텔레메트리
  • 배포와 변경 이벤트를 메트릭 그래프에 함께 표시: 배포 파이프라인에서 놓친 제품 에러를 텔레메트리 이용해서 발견 가능
  • 모두가 전체 밸류 스트림의 건강 상태를 책임지는 문화
  • 론치 가이드, 론치 요구사항: 모든 개발이 전체 조직의 누적된 경험을 활용
가설 검증 통합
  • 목표를 달성했는지 검증할 수 있는 실험을 실시
  • A/B 테스트를 프로세스에 통합
리뷰와 조율 프로세스
  • 결합도를 낮춰 소통과 조율 필요성을 감소: 위험 완화 위해 변경을 공지하고 충돌 발견, 고위험 영역의 변경은 기술적 조치
  • 변경 승인 프로세스를 리뷰로 대체: 짝 프로그래밍, 코드 리뷰, 작은 배치 크기로 원활한 리뷰
  • 긴 변경 승인 프로세스 제거

지속적 배움과 실험

일상 업무에서의 배움
  • 저스트 컬처: 배움 관점에서 실수와 에러 접근. 휴먼 에러는 주어진 도구의 피할 수 없는 설계 문제에서 기인함, 탓하지 않느 사후 분석 미팅
  • 사후 미팅 결과를 전사에 공유해 조직이 배울 수 있도록 함
  • 혁신을 위한 위험 감수 문화: 리더의 노력 필요
  • 회복성 엔지니어링으로 회복성 향상
로컬 발견을 조직 전체의 개선으로
  • 업무 프로세스에 챗룸을 활용해서 지식 전파를 빠르게 함
  • 소프트웨어 표준 프로세스를 자동화: 문서나 프로세스를 실행 가능한 형태로 변환해서 리포지토리에 추가
  • 비기능 요구사항을 체계화
  • 재사용가능한 운영 유저 스토리를 개발에 구축: 반복되는 IT 운영 작업을 개발 작업에 함께 표시
  • 조직 목표 달성 위한 기술 선택: 운영이 지원하는 기술 목록 지정
배움, 개선 위한 시간 확보
  • 기술 부채를 감소하기 위한 활동을 일정을 잡아 진행
  • 가르치고 배우는 문화: 내부 세미나, 코드 리뷰, 컨퍼런스, 내부 컨설팅/코칭

보안, 규제, 변경 관리

보안

  • 보안을 개발 이터레이션 시연에 통합: 인포섹을 초기부터 참여시킴
  • 보안도 결함 추적과 사후 작업에 통합
  • 공유 리포지토리, 공유 서비스에 보안 예방 수단 통합: 보안 관련 라이브러리나 서비스에 대한 교육 제공, 안전한 빌드 이미지나 쿡북 제작
  • 배포 파이프라인에 보안 테스트 통합
  • SW 공급 체인 보안 검토
  • 환경에 대한 보안 관련 모니터링 추가
  • 보안 관련 텔레메트리 추가
규제, 변경 관리
  • 보안/규제를 변경 승인 프로세스에 통합
  • 효과적인 변경 관리 정책 구축
    • 표준 변경: 저위험 변경으로 자동 승인, 사전 승인 가능
    • 일반 변경: 리뷰나 승인이 필요한 위험한 변경
    • 긴급 변경: 긴급한 고위험 변경으로 즉시 반영
  • 저위험 변경을 표준 변경으로 재분류
  • 일반 변경을 표준으로 바꾸는 노력 필요
  • 감사 조직을 위한 문서와 근거 자료 생성: 텔레메트리 활용


  1. 강남 2018.09.13 02:27

    잘보고 가욤 ^^

+ Recent posts