Oracle JDBC Memory Management

이 문서는 Oracle JDBC Memory Management 를 번역한 것 입니다. 일부 오역과 오타가 있을 수 있습니다.

Introduction

데이터베이스 애플리케이션들은 아주 많은 양의 메모리를 사용할 수 있다. 큰 스케일의 JDBC 애플리케이션들은 그들이 사용하는 아주 많은 메모리 때문에 성능상의 문제를 발생시킬 수 있다. 오라클 데이터베이스 10i, 11g JDBC 드라이버는 의도적으로 성능 향상을 위한 많은 메모리 사용과 트레이드 오프 관계다. Oracle Database 12c 드라이버는 메모리를 좀 더 절약하지만 여전히 아주 큰 애플리케이션은 메모리 문제를 일으킬 수 있다. 이 화이트 페이퍼는(White paper) 다양한 드라이버들이 메모리를 어떻게 사용하고 최고의 성능을 위해서 그들을 어떻게 튜닝해야 하는지에 대한 약간의 식견을 제공한다.

Oracle Database 12c 에서 드라이버들의 메모리 관리는 Oracle Database 12c 에서 소개된 VARCHAR 컬럼의 32K 제한을 지원하고, 메모리 사용을 최소화하면서 최고의 성능을 내도록 디자인 되었다. 12c 메모리 관리 체계는 약간의 오버헤드를 유발하지만, 감소된 메모리 공간은 일반적으로 10i 나 11g 보다 낫거나 동일한 성능을 제공한다. 대규모 데이터 애플리케이션도 12c 드라이버를 사용한다고 하더라도 많은 메모리를 사용할 수 있다. 만약 여러분의 애플리케이션이 수용할만한 성능을 낸다면 메모리 사용에 대해 고민할 이유가 없다. 만약 여러분의 애플리케이션이 바라던 성능이 나오지 않으면서 기대 이상의 많은 메모리를 사용한다면 이 문서를 읽어보길 바란다.

Where Does It All Go?

JDBC 드라이버는 많은 곳에 메모리를 사용하지만 가장 큰 문제는 쿼리 결과를 저장하기 위해 사용하는 버퍼(buffer) 다. 각 명령문은(Statement, PreparedStatement 와 CallableStatement 포함) 메모리에 쿼리 결과를 저장한다. 12c 에서 각 명령문은 쿼리 결과를 저장하기 위해 byte[] 버퍼세트을(buffer set) 가진다. 10i, 11g 에서 각 명령문은 두개의 버퍼를 가지는데 하나는 byte[] 이고 다른 하나는 char[] 이다. char[] 는 character 타입(CHAR, VARCHAR2, NCHAR, etc)의 모든 로우 데이터를(row data) 저장한다. 나머지 데이터 타입은 byte[] 에 저장된다. 

10i 와 11g 에서, 일반적으로 명령문이 실행될때에 SQL 스트링이 파싱되는데(구문 분석) 이때 버퍼가 할당 된다. 명령문은 (접속이) 닫힐때까지 이러한 두개의 버퍼를(char[], byte[]) 들고 있게 된다. SQL이 파싱될때 버퍼가 할당되면, 그 크기는(버퍼의 크기) 쿼리에 의해서 리턴되는 실제 로우 데이터(row data) 크기와 상관 없지만, 로우 데이터의 가능한 최대 크기와 관련이 있다. SQL 이 파싱된 후에, 모든 컬럼의(column) 타입을 알고 있고, 이 정보를 이용해 JDBC 드라이버는 각 컬럼을 저장하기 위해 필요한 최대 메모리 양을 계산할 수 있다. 드라이버는 각 페치(fetch) 할때 가지고 올 행수인(the number of rows) fetchSize 를 가진다. (역, 데이터를 가지고 오는 작업을 Fetch 라고 한다. Oracle JDBC 드라이버는 한번에 한 개의 로우를(레코드) 가지고 오는게 아니라 fetchSize 만큼 여러개의 로우를 한번에 가지고 올 수 있다.) 각 컬럼의 크기와 로우 개수와 함께, 드라이버는 단일 페치(single fetch)에서 리턴되어지는 데이터의 최대 크기를 정확하게 계산할 수 있게 되는데, 이것이 버퍼의 크기가 된다.

반면에, 12c 에서 버퍼는 드라이버가 서버로부터 결과 데이터를 읽을때 요청되고 할당 된다. 이것은 10i 나 11g 와 비교해 봤을때 약간의 추가적인 오버헤드 비용이 있지만 쿼리 결과를 저장하기 위해 필요로 하는 메모리 양이 최소화 된다. LONG, LONG RAW 와 같은 타입은 버퍼에 인라인(inline) 으로 저장하기에는 매우 클 수 있고 다루기 어렵다. 기본적으로, 만약 쿼리 결과가 LONG, LONG RAW 타입을 포함한다면 fetchSize는 1로 설정되고, 이것은 향후 명확해질 대부분의 메모리 문제를 해결한다. 

10i 와 11g 에서 Character 데이터는 char[] 버퍼에 저장된다. Java에서 chars 는 한 Character 당 2 byte 이다. (10i, 11g 에서) A VARCHAR2(10) 컬럼은 최대 10개의 Character 를 가질 것이며 Java 에서 chars 는 row 하나당 20byte 를 가질 것이다. A VARCHAR2(4000) 컬럼은 8k bytes/row 를 가질 것이다. 핵심은 실제 데이터 크기가 아니라 컬럼의 크기로 정해지고 있다는데 있다. A VARCHAR2(4000) 컬럼이 모두 NULL 을 가진다 하더라도(실제 데이터가 없다 하더라도) 여전히 8K bytes/row 의 버퍼 메모리가 할당 된다. 버퍼는 쿼리 결과를 보기전에 할당되기 때문에 드라이버는 반드시 아주 큰 쿼리 결과값을 예상해 충분히 큰 메모리를 할당해야 한다. VARCHAR2(4000) 으로 정의된 컬럼은 4000 Character 로 꽉꽉 채워질 수 있다. 버퍼는 반드시 4000 chars 를 가질수 있는, 실제 결과 데이터가 그렇게 크지 않다고 하더라도, 충분한 메모리를 할당해야 한다.

BFILE, BLOB 그리고 CLOB 값들은 로케이터(locator) 처럼 저장된다. 로케이터는 BFILE, BLOB 그리고 CLOB 컬럼에 각각 4K bytes 일 수 있는데, byte[] 는 적어도 4K bytes/row 를 가져야 한다. RAW 컬럼들은 4K Bytes 이상 가질 수 있다. 다른 타입들은 대체로 이 보다 적게 갖는다. 대충 다른 모든 타입은 22 bytes/colums/row 로 가정한다.

드라이버가 executeQuery 메소드를 실행하면, 데이터베이스는 SQL 을 구분 분석, 즉 파스(parse) 한다. 데이터베이스는 결과가 세 개의 컬럼을 가질거라고 보고할 것이다: a NUMBER(10), a VARCHAR2(40) 그리고 a DATE. 첫번째 컬럼은 대략 22 bytes/row 가 필요하다. 두 번째 컬럼은 40 chars/row 가 필요하다. 세번째 컬럼은 대략 22 bytes/row 가 필요하다. 따라서 하나의 로우(row) 는 22 + (40*2) + 22 = 124 bytes/row 를 필요로하게 된다. (각 Character 들은 2 bytes 라는 걸 기억해라) 기본 fetchSize 가 10 로우일 경우에 드라이버는 10 개의 char[], 10 * 40 = 400 chars (800 bytes) 그리고 10 개의 byte[], 10 * (22+22) = 440 bytes 그래서 총 1240 bytes 를 할당할 것이다. (역, 그냥 한 로우 124 bytes/row * 10 = 1240 bytes 다.) 1240 bytes 는 메모리 문제를 야기하지 않는다. 하지만 쿼리 결과가 아주 클 경우에는 문제가 될 수 있다.

최악의 경우로 쿼리 결과가 255 개의 VARCHAR2(4000) 컬럼 리턴한다고 가정해 보자. 각 컬럼은 8k bytes/row 를 갖는다. 225 개의 컬럼이니까 2040K bytes 혹은 2MB/row 다. 만약 fetchSize 가 1000 개의 로우(row) 라면 드라이버는 2GB char[] 메모리를 할당하려고 할 것이다. 이건 좋지 않다.

12c JDBC 드라이버들은 오직 쿼리 메타데이터(metadata) 와 실제 쿼리 데이터를 저장하기 위한 메모리를 할당 한다. (10i, 11g 에서는) 각 컬럼별로 최대 가능 값을 저장하기 위한 메모리를 미리 할당하는 대신에, 12c 드라이버들은 오직 실제 컬럼 값들을 저장하기에 필요한 것만큼만 메모리를 할당 한다. 이것은 추가적인 오버헤드를 요구받지만 거의 모든 상황에서 메모리 사용량이 크게 줄어든다. 

12c 드라이버는 결과 쿼리값에 15 bytes 를 할당하지만 (15 bytes/value), 실제 데이터 값을 저장하기 위해 훨씬 많은 메모리를 필요로 한다. 만약 값이 null 이면 오직 15 byte 만 할당 된다. 만약 컬럼이 VARCHAR2(32000) 이고 실제 데이터가 32,000 characters 면, 15 + 64,000 bytes (2bytes/char) 크기의 메모리를 할당 한다. 만약 컬럼에 다음 데이터가 1 character 이면 15 + 2 bytes 가 할당 된다. 

이것은 10i 와 11g 접근방법을 근본적으로 벗어난 것이다. 만약 모든 값들이 최대 크기라면 12c 는 10i 와 11g 보다 13 bytes/value 를 더 사용한다. 이것은 매우 드문 케이스다. 더 일반적으로 많은 NULL 과 크기가 가변적인 VARCHAR 값들이 있다. 아주 드문 케이스를 제외하고 12c 드라이버는 10i 이나 11g 보다 메모리를 적게 사용할 것이다. 

12c 드라이버는 오직 byte 버퍼만 사용한다. char 버퍼는 없다. 버퍼는 전부 같은 길이다.(The buffers are all the same length) 그들은 캐시되고 재사용되어진다. 버퍼 캐시는(buffer cache) Java Memory Management Team 과 협력해 메모리 소비를 최소화하면서 재사용성을 최적화하도록 디자인 되었다. 12c 버퍼 크기가 10i와 11g의 최소 버퍼 크기보다 크다는 점에 유의할 필요가 있다. 아주 작은 쿼리 결과에서는 더 많은 메모리를 사용하겠지만 12c 와 10i, 11g 비교했을때 몇 kilobytes 밖에 차이가 나지 않는다.

Managing the buffer sizes

버퍼에 의해서 사용되어지는 많은 양의 메모리를 관리하기 위해 사용자가 할 수 있는 것들이 몇가지 있다.

  • 신중하고 주의해서 테이블 정의하기
  • 신중하고 주의해서 쿼리 짜기
  • 신중하고 주의해서 fetchSize 를 지정

VARCHAR2(4000) 과 VARCHAR2(20) 와 같은 컬럼은 10i, 11g 와 아주 큰 차이를 만들어 낸다. VARCHAR2(4000) 컬럼은 8K bytes/row 를 필요로한다. 실제 컬럼이 20 character 보다 더 많이 값을 가지고 있지 않게되면 VARCHAR2(4000) 에 대한 10i, 11g 에 의해서 할당된 대부분의 버퍼는 낭비하게 된다. (역, VARCHAR2(4000) 컬럼에 실제 데이터는 20 char 가 들어가 있는데 10i 와 11g 는 컬럼의 크기를 기반으로 최대 값을 할당하기 때문에 VARCHAR2(4000) 컬럼을 위한 버퍼는 낭비하게 된다.) 12c 드라이버에서는 이런 일이 발생하지 않는다. 

오직 몇개의 컬럼만 필요한데도 SELECT * 을 실행하면 버퍼 크기뿐만 아니라 성능상에 큰 영향을 준다. 이것은 로우 컨텐츠를 가지고 오고, 바꾸고, 네트워크를 통해서 전송하고 자바 표현식으로 다시 바꾸는데 많은 시간이 든다. 오직 몇개의 컬럼만 필요한데도 많은 컬럼을 리턴하면 10i 와 11g 드라이버는 불필요한 결과를 저장하기 위해서 아주 큰 버퍼를 할당하게 된다. 12c 드라이버는 실제 컬럼값에 대해서만 메모리 할당을 강제한다. 이것은 10i 와 11g 보다 작을 수 있지만 12c 드라이버는 NULL 에 대해서도 15 bytes/value 를 할당하기 때문에 여전히 낭비다.

메모리 사용을 제어하는 기본적인 툴은 fetchSize 다. 비록 2MB 는 아주 크지만, 대부분의 자바 환경에서 그 크기를 버퍼에 할당하는 것은 전혀 문제를 발생시키지 않는다. Oracle database 11 의 최악의 케이스 결과로 255개의 VARCHAR2(4000) 컬럼 조차도 fetchSize 가 1 이라면 대부분의 애플리케이션에서 문제가 되지 않는다. Oracle database 12 의 최악의 케이스 1000 개에 VARCHAR2(32000) 은 10i와 11g 드라이버에서 64MB/row 를 필요로 한다.(3200 * 2 = 64000, 1000 개의 컬럼이 있으니까 64000 * 1000 = 64,000,000 이다.) 비록 fetchSize 가 1이라 할지라도 많은 자바 환경에서 문제를 발생시킬 수 있다. 12c 드라이버는 오직 실제 데이터를 저장하기 위해 필요로하는 메모리만 할당 한다. 

메모리 사용 이슈를 다루는 첫 단계는 SQL 을 검토하는 것이다. 각 쿼리에 대해 로우(row) 당 사용될 대략적인 크기를 계산하고 fetchSize 를 확인해라. 로우당 크기가 메우 크다면 좀 더 적은 컬럼을 페치(fetch) 하는게 가능한지(역, SELECT 에서 가지고 올 컬럼을 지정해야 한다. SELECT * 은 무조건 피해야 한다.) 혹은 데이터 크기를 좀 더 타이트하게 제약하기 위해 스크마 수정이 가능한지를 살펴보라. 마지막으로 적당한 크기에 버퍼를 유지하기 위한 fetchSize 를 지정한다. Oracle 은 비록 어떤 케이스에서 큰 크기가 알맞다라고 하더라도 fechSize 를 100 보다 크지 않기를 권한다. 아주 많은 로우를 리턴하더라도 일부 쿼리에 대해 fetchSize 100은 부적절하게 아주 클 수 있다. 

Note: 오라클의 특볗한 메소드 OracleStatement.defineColumnType 은 지나치게 큰 크기로 정의된 컬럼의 크기를 줄이기 위해 OCI 드라이버와 함께 사용되어 질 수 있다. 크기 인자와 함께 호출되면, 그 크기가 해당 컬럼에 대해 스키마에 정의된 크기보다 우선 한다. 이것은 문제를 해결하기 위해 스키마를 마음대로 수정할 수 없는 경우에 해결할 수 있게 해준다. 여러분은 주어진 명령문에서 defineColumnType 을 전혀 호출하지 않거나 그 명령문에서 모든 컬럼에 defineColumnType을 호출해야만 한다. 스키마를 고치는게 가능한 최고의 방법이다. defineColumnType 메소드는 BLOB 및 CLOB 컬럼의 LOB 프리 페치 크기를 지정하는 것을 제외하고 12C Thin 드라이버에서 지원되지 않는다.

One statement does not make a problem

VARCHAR2(32000) 타입의 1000 컬럼이나 setFetchSize(100000)과 같은 극단적인 케이스를 제외하고 단일 명령문은 메모리 사용 이슈를 발생시키지 않는다. 실제로, 문제는 수백 혹은 수천만 명령문 객체가 있는 시스템에서 나타난다. 대규모 시스템에는 동시에 수백 개의 연결이(connection) 열려 있을 수 있다. 각각의 연결은 한 두개의 명령문을 동시에 열 수 있다. 이렇게 큰 시스템은 아주 많은 물리적 메모리를 가진 머신에서 운영된다. 따라서 수백 개의 명령문을 오픈하는 대규모 시스템을 가정하면 심각한 메모리 문제는 발생하지 않을 것 같다. 물론, 드라이버도 많은 메모리를 사용할 수 있지만 메모리는 원래 그렇게 사용된다. 실제로 대규모 시스템도 메모리 문제를 피할 수 있다.

대규모 시스템은 같은 SQL 을 여러번 실행하는 경향이 있다. 성능상의 이유로 여러번 실행할때 마다 각각의 SQL에 대해서 처음부터 다시 만드는 것보다 PreparedStatement 를 재사용하는 것이 좋다. 그래서 대규모 시스템에는 각각 구별되는 SQL 에 대해서 하나 이상의 많은 PreparedStatement 를 가질 수 있다. 대부분의 대규모 시스템들은 Weblogic Server 같이 모듈러 프레임워크를 사용한다. 프레임워크안에 독립 컴포넌트들은 그들이 필요로 하는 PreparedStatement 를 생성한다. 이것은 PreparedStatement를 유지해야 할 필요성과 충돌한다. (역, 프레임워크 안에서 독립 컴포넌트들이 고유의 PreparedStatement 를 생성하기 때문에 재상용을 위해 준비된 Oracle JDBC 의 PreparedStatement 를 사용하지 않는다는 뜻이다.) 이 요구 사항을 해결하기 위해 프레임 워크는 명령문 캐싱을 제공한다. 명령문 캐싱을 가지고 있으면 각각의 연결이 메모리에 수백 혹은 그 이상의 PreparedStatement 를 가지는 것이 쉽다. 이것은 수백, 수천개의 커넥션이 생성되면 실제로 메모리 문제가 발생할 가능성이 있다. 

Oracle JDBC 드라이버는 드라이버에 내장된 명령문 캐시를, 묵시적 명령문 캐시(Implicit Statement Cache), 통해서 이 문제를 해결한다. (명시적 명령문 캐시도 있지만 여기서 다루지 않는다.) 묵시적 명령문 캐시는 투명하다. 사용자는 단지 새로운 객체를 생성하는 것처럼 PrepareStatement 를 호출한다. 만약 드라이버가 prepare 호출이 캐시에 있다면 새로운 객체를 캐시로부터 사용자에게 리턴한다. 하지만 없으면 새로운 객체를 생성한다. 문법적으로 사용자 코드는 새로운 객체와 재사용 객체를 구분할 수 없다. 성능적인 측면에서 새로운 객체를 생성하는 것보다 캐시에서 명령문을 리턴하는 것이 훨씬 빠르다. 캐시된 명령문의 첫 실행은 드라이버와 서버가 이전 실행으로부터 아주 많은 상태들을 재사용할 수 있음으로 해서 훨씬 빠르다. 

묵시적 명령문 캐시는 Oracle JDBC PreparedStatement 의 내부 구조를 알고 있다. 이것은 최적의 성능을 위한 구조로 관리를 할 수 있음을 뜻 한다. 특히, 이것은 char[] 와 byte[] 버퍼를 관리할 수 있다. Oracle 은 실제 애플리케이션에서 서로 다른 버퍼 관리 체계가 어떻게 동작해야 하는지 좀 더 잘 인식하도록 개발됨에 따라 드라이버 버전 마다 다른 방법으로 버퍼를 관리한다. 10i 와 11g JDBC 드라이버는 PreparedSatement 가 묵시적 명령문 캐시에서 리턴될때에만 char[] 와 byte[] 버퍼를 관리 할 수 있다. 만약 PreparedSatement 가 닫히지 않으면, Oracle JDBC 메모리 관리 드라어버는 명령문이 즉시 재사용되지 않을지를 알 방법이 없으며, 그래서 버퍼 사용 관리를 위해 아무것도 할 수 없다. 12c 드라이버는 좀 더 다이나믹한 버퍼 메커니즘을 가지고 있고 ResultSet 이 닫힐때 캐시에서 버퍼를 리턴한다. Oracle 은 여전히 묵시적 명령문 캐시 사용을 권장하지만, 12c 드라이버는 Weblogic Server 와 같은 다른 명령문 캐쉬를 사용할때에도 과도한 메모리 소비를 하지 않는다.

Statement Batching and Memory Use

row 데이터 버퍼는 Oracle JDBC 드라이버가 생성할 수 있는 유일하게 큰 버퍼가 아니다. Oracle JDBC 드라이버는 데이터베이스에 PreparedStatement 파라메터를 전달하기 위해 큰 버퍼를 생성할 수 있다. 애플리케이션은 일반적으로 한번에 적은 양의 데이터를 쓰고 그들의 쓰는것보다 더 많은 양의 데이터를 읽는다. 따라서 파라메터 데이터 버퍼는 row 데이터 버퍼보다 훨씬 작은 경향이 있다. 하지만 잘못된 명령문 배치를 사용하면 드라이버가 아주 큰 버퍼를 생성하게 된다.

애플리케이션이 파라메터 값을 지정하기 위해 PreparedStatement setXXX 를 호출할때, 드라이버는 값을 저장한다. 이것은 적은 메모리를 갖는다; 단지 String 과 같은 Objejct 타입, long 과 double 의 8byte, 다른 모든 것은 4 bytes 와 배열을 레퍼런스 한다. PreparedStatment 실행될때, 드라이버는 Java 타입이 아닌 SQL 타입으로 데이터베이스에 값들을 전달해야 한다. 10i, 11g 드라이버는 byte[] 와 char[] 버퍼를 생성한다. 파라메터 데이터는 버퍼에 저장할 SQL 표현으로 변환 된다. 그리고 나서 드라이버는 네트워크를 통해서 바이트를 전송한다. 드라이버는 버퍼를 할당하기 전에 실제 데이터 크기를 가지기 때문에, 최소 크기 버퍼를 생성할 수 있다. 만약 새로운 데이터 값들이 더 큰 byte[] 나 char[] 버퍼를 필요로한다면, 더 큰 버퍼를 할당 한다. 적당한 양의 메모리를 가지면, 단일 명령문 실행중에 Out of Memory 가 나지 않는다. 하지만 명령문 배칭은 다르다.

명령문 배칭은 하나의 연산으로(operation) 단일 DML 명령문을 여러번 실행한다. 이것을 실행하기 위해서 드라이버는 한번에 모든 DML 실행을 위해 모든 파라메터 값들을 전송해야만 한다. 이것은 드라이버가 모든 파라메터 데이터를 SQL 표현식으로 변환하고 버퍼에 저장해야만 한다. 배치에서 실행 수는, 배치 크기(batch size), 쿼리에 대한 fetch 크기와 유사하다. 단일 명령문 실행에 대한 매개 변수 변환이 메모리 문제를 일이키지는 않지만, 대규모 배치 크기라면 문제가 될 수 있다. 

실제로, 이것은 흔하지 않은 문제며 적합하지 않은 큰 배치 크기(수십만 개정도) 일 때만 나타난다. 매번 수백개의 정도 로우의 executeBatch 를 호출하는 것으로 문제를 해결해야 한다.

12c 드라이버는 아주 큰 배치 크기를 갖는 경우에 배치를 분리시킴으로서 이 문제를 해결한다. 이것은 배치에서 수백만개의 로우를 Out of Memory 없이 다룰 수 있게 해준다. 대신 한번에 모든 로우를 보내기 보다는 모든 로우를 보내기 위해서 여러번 왕복을 해야 할 것이다.(역, 배치를 나눴으니까..) Oracle 은 여전히 아주 큰 배치 크기일 경우에 좀 더 적은 수백개의 로우로 매번 executeBatch 를 호출하도록 권장한다.

Version Specific Memory Management

이번 섹션에서는 다양한 버전의 Oracle JDBC 드라이버들이 어떻게 버퍼 메모리를 다루며 최고의 성능을 내기위해서 사용자가 어떻게 드라이버를 튜닝할 수 있는지에 대해서 다룬다.

Note: 세부적인 메모리 관리를 논의할때에 10i와 11g 드라이버 버퍼가 구체적으로 char[] 와 byte[] 를 가진다는 것을 무시하는 것이 편리하다. 이번 섹션에서 기억해야할 것은 명령문에 대해서 char[] 와 byte[] 버퍼가 그냥 일반적으로 “버퍼” 라고 생각하는 것이다.

비록 Java 메모리 관리가 아주 훌륭하지만, 아주 큰 버퍼 할당은 비용이 많이 든다. 이것은 실제 메모리 할당 비용이 아니다. 그것은 매우 빠르다. 문제는 모든 버퍼를 Zero filled 를 요구하는 Java 언어다. 단순하게 큰 버퍼를 할당하는 것이 아닌 반드시 Zero filled 여야 한다. Zero filling 은 모든 할당된 버퍼의 바이트에 대해 터칭(touching)을 요구한다. 다중레벨 데이터 캐시를 가지는 현대의 프로세서들은 작은 버퍼를 가진다. 아주 큰 버퍼의 Zero filling 은 그 크기가 프로세서 데이터 캐시를 초과하고 Zero filling 작업은 메모리 스피드로 실행 되는데, 이는 대체로 프로세스 스피드보다 느리다. 이 문제에 대한 성능 테스트는 드라이버에서 버퍼할당이 아주 큰 성능상 하락을 반복적으로 보여줬다. 이로 인해 버퍼 할당 비용과 재사용을 위해 버퍼를 절약하는 데 필요한 메모리 공간 간의 균형을 맞추는 데 어려움을 겪는다.

Oracle Database Release 10g Oracle JDBC Drivers

초기 10g 드라이버는 메모리 관리에 대한 접근이 순진했다. 그들은 최고의 성능을 위해 메모리를 관리한다. PreparedStatement 가 처음 실행될때, 필요한 byte[] 와 char[] 버퍼가 할당 된다. 그것뿐이다. 버퍼는 PreparedStatement 가 해제 될때에만 해제 된다. 묵시적 명령문 캐시는 버퍼를 관리하기 위해 아무것도 하지 않는다. 묵시적 명령문 캐시에서 모든 PreparedStatement 는 할당된 byte[] 와 char[] 버퍼를 즉시 재사용되도록 유지한다. 따라서 이 드라이버 버전에서 메모리 관리는 setFetchSize 사용, 신중하고 주의깊은 스키마 설계, 신중하고 주의깊은 SQL 쿼리를 코딩하는 것 뿐이다. 초기 10g 드라이버는 충분히 빠르지만, OutOfMemoryExceptions 를 포함한 메모리 관리 이슈를 가질 수 있다.

Oracle Database Release 10.2.0.4 Oracle JDBC Drivers

10.2.0.4.0 드라이버는 초기 10g 드라이버에서 나타난 메모리 관리 이슈 문제를 해결하기 위해서 시작시에 커넥션 속성이 추가 됐다. 이 커넥션 속성은 모 아니면 도다. 만약 이 속성이 지정되면, PreparedStatement 를 묵시적 명령문 캐시로 반환하면 버퍼가 해제된다. 버퍼는 명령문이 캐시로부터 반환될때 재할당 된다. 이런 단순한 접근은 극적으로 메모리 사용을 줄여주지만 상당한 성능 비용을 필요로 한다. 앞에서 서술했듯이, 버퍼 할당은 비싸다.

connection 속성은 다음과 같다.

oracle.jdbc.freeMemoryOnEnterImplicitCache

이 값은 “true” 나 “false” 를 가지는 boolean 이다. 만약 “true” 라면 버퍼는 PreparedStatement 가 묵시적 명령문 캐시로 반환될때 해제 된다. 만약 “false” 라면, 기본 값이다, 버퍼는 초기 10g 드라이버처럼 유지 된다. 이 속성은 -D 를 통해 시스템 속성으로 지정하거나 getConnection 메소드에 커넥션 속성으로 지정할 수 있다. 주의할 것은 freeMemeoryOnEnterImplicitCache 세팅은 파라메터 값 버퍼 해제를 발생시키지 않으며 오직 로우 데이터(row data) 버퍼 해제만 발생시킨다.

Oracle Database Release 11.1.0.6.0 Oracle JDBC Drivers

JDBC 개발 팀은 10.2.0.4.0 에 모 아니면 도식의 접근법이 이상적이 않다는 것을 깨달았다. 11.1.0.6.0 드라이버는 메모리 관리에 좀 더 세련된 접근법을 가진다. 그건 사용하지 않는 메모리의 최소화, 버퍼 할당 비용의 최소화 라는 두가지 목표가 있다. 이 드라이버는 각 커넥션에 대해 내부 버퍼 캐시를 소개했다. PreparedStatement 가 묵시적 명령문 캐시로 반환되면 버퍼 캐시에 캐시된다. 

서론에 언급 된 바와 같이, 버퍼의 크기는 0에서 수십 또는 수백 메가 바이트까지 광범위하게 변할 수있다. 11.1.0.6.0 버퍼 캐시는 아주 단순하다. 모든 캐시된 버퍼들은 모두 같은 크기다. 버퍼는 묵시적 명령문 캐시에서 모든 PreparedStatement 에 대해서 사용되어질 수 있기 때문에 그 크기는 아주 큰 요청을 가지는 PreparedStatment 만큼의 충분히 큰 크기를 가진다. 만약 한번에 하나의 명령문만 사용중인 경우 하나의 버퍼만 있으며 해당 버퍼는 모든 PreparedStatement 에서 사용된다. 일부 또는 대부분의 명령문의 경우 버퍼가 아주 클 수 있지만, 캐시에 있는 적어도 하나의 명령문에 대해서는 적절한 크기일 수 있다. PreparedStatement 재사용 패턴이 너무 편중되지 않으면, 작은 버퍼를 유지하고 필요에 따라 큰 버퍼를 재 할당하는 것보다 큰 버퍼를 유지하고 지속적으로 재사용하는 것이 더 효과적이다. 여러 명령문이 한번에 열리거나 아주 큰 버퍼를 필요로하는 PreparedStatement 가 하나 있는 경우 잠재적으로 메모리 문제가 있다.

10MB 버퍼를 필요로하는 하나의 PreparedStatement 과 나머지는 아주 작은 버퍼를 사용하는 애플리케이션이 있다고 가정해 보자. 한번에 커넥션당 하나의 명령문만 사용하고 아주 큰 PreparedStatement 가 충분히 자주 사용되면 문제는 없다. 각 명령문이 사용할때마다 단일 10MB 버퍼를 할당하며 PreparedStatement 가 묵시적 명령문 캐시로 반환될때 버퍼 캐시로 캐시된다. 단일 10MB 버퍼는 한번 할당되며 다양한 PreparedStatement 에 의해서 지속적으로 재사용 된다. 이제 한번에 두개의 PreparedStatement 가 열리면 무슨 일이 생기는지 생각해보자. 둘다 버퍼를 가져야 한다. 모든 PreparedStatement 는 버퍼에 할당되어야 함으로 모든 버퍼는 반드시 같은 크기, 최대 크기를 똑같이 가져야만 한다. 두개의 PreparedStatement 가 한번에 열릴때 버퍼는 각각 10MB 여야 한다. 두번째 PreparedStatement 가 열리는 중에, 그것이 아주 작은 용량의 버퍼를 필요로한다고 하더라도 10MB 버퍼가 할당된다. 만약 세번째 명령문이 열리면, 세번째 10MB 버퍼가 할당된다. 수백개의 커넥션과 한번에 수백개의 PreparedStatement 가 열리는 대규모 시스템에서 모든 PreparedStatement 에 대한 아주 큰 버퍼 크기는 메모리를 넘치게할 가능성이 있다. 뒤돌아보니 (문제가) 명확하지만, 개발팀은 이것이 얼마나 큰 문제인지 판단하지 않았고 문제가 있음을 내부 테스트에서 인지하지 못했다. 이 이슈는 적절한 스키마 디자인, SQL 코딩 그리고 fetchSize 선택을 통해서 최소화 될 수 있다.

주의해야할 것은, 11.1.0.6.0 드라이버는 버퍼처럼 freeMemoryOnEnterImplicitCache 를 지원하지 않으며 그것을 캐시에 넣을때 PreparedStatement 에 의해서 항상 해제된다. 해제된 버퍼들은 내부 버퍼 캐시에 저장된다.

Oracle Database Release 11.1.0.7.0 Oracle JDBC Drivers

11.1.0.7.0 드라이버는 아주 큰 버퍼 문제를 해결하기 위해서 커넥션 속성을 소개 한다. 이 속성은 버퍼 캐시에 저장되어질 최대 버퍼 크기와 연관된다. 모든 큰 버퍼들은 PreparedStatement 가 묵시적 명령어 캐시로 집어넣을때 해제되고 PreparedStatement 가 캐시로부터 데이터를 받을때에 재할당 된다. 대부분의 PreparedStatement 가 예를들어 100KB 미만의 적당한 크기의 버퍼를 필요로하지만 일부는 훨씬 더 큰 버퍼를 필요로하는 경우, 커넥션 속성을 110KB 로 설정하면, 자주 최대 크기 버퍼 할당에 부담을주지 않고 자주 사용되는 작은 버퍼를 재사용 할 수 있다. 이 속성을 설정하면 성능 향상되고, OutOfMemoryException 을 방지할 수 있다.

이 커넥션 설정은

oracle.jdbc.maxCachedBufferSize

이 값은 “100000” 처럼 정수 문자열(int string) 이다. 기본값으로 Integer.MAX_VALUE 다. 이것은 내부 버퍼 캐시에 저장할 수 있는 버퍼에 대한 최대 크기다. 하나의 크기로 char[] 와 byte[] 버퍼를 모두 사용한다. 그 크기는 char[] 버퍼의 경우 문자로(chars) byte[] 버퍼의 경우 byte로 표시된다. 이것은 미리 정의된 크기가 아니라 최대 버퍼 크기다. 만약 maxCachedBufferSize 가 100KB 로 설정되었지만 최대 버퍼 크기가 100KB 보다 적은 50KB 라면, 버퍼 캐시의 버퍼들은 50KB 가 될 것이다. maxCachedBufferSize 값의 변경은 드라이버의 내부 버퍼 캐시에서 char[] 나 byte[] 버퍼를 포함하거나 제외할때만 성능이 달라진다. 아주 큰 변화, megabytes 조차, 차이가 없다. 마찬가지로 하나를 변경하면 PreparedStatement 의 버퍼를 포함하거나 제외하하는 일이 발생할때에 차이가 난다. 이 속성은 -D 를 통해 시스템 속성처럼 지정하거나 getConnection 을 통해서 커넥션 속성처럼 지정할 수 있다.

만약 여러분이 maxCachedBufferSize 이 설정이 필요하다면, 큰 버퍼들이 필요로하는 SQL 쿼리에 대한 버퍼 크기를 측정하는 것으로부터 시작해야 한다. 이 과정에서 이러한 쿼리에 대한 fetch 크기를 튜닝하면 여러분이 바라는 성능을 얻을 수 있다. 실행 빈도와 버퍼 크기를 고려해 대부분의 명령문이 캐시된 버퍼를 사용할 수 있도록 크기를 정해야 하지만, Java 런타임이 새로운 버퍼를 할당해야하는 빈도를 최소화하기 위해 필요한 버퍼 수를 지원할 수 있을 정도의 충분히 작은 크기여야 한다.

어떤 애플리케이션들은 쓰레드 개수에 비해 많은 idle 커넥션을 가진다. 애플리케이션은 많은 데이터베이스 중에 하나에 접속을 필요로 하지만 한번에 하나만 접속한다. 만약 각 데이터베이스에 스레드당 대충 하나의 커넥션이 있고 스레드보다 더 많은 데이터베이스가 있는 경우에 스레드보다 더 많은 idle 커넥션을 가진다. 기본적으로 버퍼 캐시는 커넥션당 가지기 때문에 idle 커넥션으로 인해서 사용하지 않는 버퍼를 버퍼에 할당한다. 이것은 필요 이상으로 큰 메모리 공간이 필요함을 의미 한다. 비교적 극단적인 상황이지만, 발생할 수 있다.

이 경우에 커넥션 속성을 지정함으로써 해결할 수 있다.

oracle.jdbc.useThreadLocalBufferCache

이 속성의 값은 Boolean 문자열, “true” 나 “false” 다. 기본값은 “false” 다. 이 속성이 “true” 로 지정되면, 버퍼 캐시는 커넥션이 아닌 ThreadLoacl 에 직접 저장된다. 만일 커넥션보다 스레드 수가 적으면 사용되는 메모리 양이 줄어들 것이다. 이 속성은 -D 를 통해서 시스템 속성이나 getConnection 을 통해 커넥션 속성으로 지정할 수 있다. 

useThreadLocalBufferCache = “true” 를 사용하는 모든 커넥션은 같은 정적 ThreadLocal 필드를 공유하며 따라서 같은 버퍼 캐시 세트를 공유한다. 만얄 useThreadLocalBufferCache = “true” 설정되어 있다면, 사용하는 모든 커넥션은 같은 maxCacheBufferSize 를 가진다. 스레드가 처음 하나의 커넥션을 사용한 다음 다른 커넥션을 사용하는 경우 두 커넥션는 사용 된 버퍼의 크기와 수에 따라 서로의 성능에 간접적인 영향을 미친다. 보통 ThreadLocal 버퍼 캐시를 사용하는 모든 커넥션은 같은 애플리케이션의 일부일 것임으로 다른 커넥션을 사용하는 경우의 서로의 성능에 간접적인 영향을 미치는 일은 없다. 만약 한 쓰레드가 명령문을 생성하고 다른 쓰레드가 명령문을 닫는다면, 버퍼는 한개의 ThreadLocal 버퍼 캐시에서 다른 ThreadLocal 버퍼 캐시로 마이그레이션할 것이고 재사용되지 않을 것이다. 이것은 사례로 권장하지 않는다. 만약 모든 명령문이 하나의 ThreadLocal 에서 생성되었고 다른 쓰레드가 닫는다면 전혀 버퍼를 재사용하지 않게 된다. 다시말해 이것은 권장하지 않는다, 만일 여러분의 애플리케이션이 이러한 경우에 속한다면 절대로 useThreadLocalBufferCache 를 true 로 세팅하지 말라. 이것은 어떤 커넥션은 ThreadLocal 버퍼 캐시를 사용하고 어떤 것은 커넥션 버퍼 캐시당 기본값을 사용할 가능성이 있다.

Oracle Database Release 11.2 Oracle JDBC Drivers

11.2 드라이버는 11.1.0.7.0 보다 더 정교한 버퍼 캐시를 가진다. 이 버퍼 캐시는 다중버킷을(multiple bucket) 가진다. 버킷에 모든 버퍼들은 모두 같은 크기이며 이 크기는 미리 정해진다. 맨 처음 PreparedStatement 가 실행되면, 드라이버는 결과를 보관할 가장 작은 크기의 버퍼를(역, 최적크기의 버퍼) 갖는 버킷으로부터 버퍼를 얻는다. 만약 버킷에 버퍼가 없다면, 버킷에 미리 정해진 알맞은 크기의 새로운 버퍼를 할당한다. PreparedStatement 가 닫히면, 버퍼는 알맞은 버킷으로 반환된다. 버퍼들은 다양한 크기에 요구사항에 사용되므로 버퍼들은 보통 필요한 최소 크기보다 약간 크다. 불일치(역, 버퍼 크기의 불일치) 발생은 제한적이며 실제로 임펙트를 주지는 않는다.

11.2 드라이버는 항상 11.1 이나 10.2.0.4.0 드라이버보다 메모리를 같게 혹은 적게 사용한다. 어찌보면 11.2 드라이버가 충분한 성능을 내는데 비해 너무 적은 힙 크기로 실행되는 것이 말이 안되기도 한다. 더 적은 메모리로 실행된다는 이유만으로 그것이 효율적이라는 뜻은 아니다. 11.2 드라이버에서 대규모의 성능향상을 위해 -Xms 값을 크게 설정하는 것은 드문일이 아니다. 아래에 자바 힙 제어하기 섹션을 보라.

11.2 드라이버는 maxCachedBufferSize 를 지원하지만 별로 중요하지 않다. 11.1 에서 정확한 maxCachedBufferSize 설정은 탁월한 성능과 OutOfMemoryException 의 차이를 만들어 낸다. 11.2 드라이버에 maxCachedBufferSize 설정은 가끔 대규모 명령문 캐시와 광범위하게 나뉘는 버퍼 크기의 요구사항을 갖는 대규모 시스템에서 성능을 개선 시킬 수 있다. 11.2 에서 maxCachedBufferSize 는 최대 버퍼 크기의 log2 로 해석된다. 예를들어, maxCahcedBufferSize 가 20 으로 설정했다면 캐시 된 최대 크기 버퍼는 2^20 = 1048576 이 된다. 이전 버전과 호환성을 위해, 30 보다 큰 크기의 값은 log2 크기가 아닌 실제 크기처럼 해석되지만, 2의 거듭 제곱을 사용하는 것이 좋다.

maxCachedBufferSize 값의 합리적인 설정은 시스템에 임팩트를 주지 않는다. 만약 여러분이 maxCachedBufferSize 를 설정해야 한다면, 18부터 시작해라. 만약 16보다 적은 값을 설정 해야한다면 아마도 더 많은 메모리가 필요하다.

11.2 드라이버는 파라메터 데이터 버퍼를 위해서 같은 크기의 버퍼 캐시와 캐싱 스키마를 사용 한다. PreparedStatement 가 묵시적 명령문 캐시에 있으면 파라메터 데이터 버퍼들은 버퍼 캐시에 캐시 된다. PreparedStatement 가 맨 처음 실행되거나 묵시적 명령문 캐시에서 검색된 후 처음으로 실행될 때 버퍼 캐시로부터 파라메터 데이터 버퍼를 얻는다. 전형적으로 파라메터 데이터 버퍼들은 로우(row) 데이터 버퍼들보다 훨씬 작지만, 이런 버퍼들은 아주 큰 배치 크기를 가질 수 있을만큼 클 수 있다. 또, 11.2 드라이버는 Bfile, Blob, Clob 연산을 위한 char[] 버퍼와 대규모 byte[] 에 대해 다른 버퍼 캐시를 사용한다. 

11.2 드라이버도 useThreadLocalBufferCache 를 매우 잘 지원한다. 이것에 대한 기능과 이것을 언제/어떻게 사용할지 대한 권장사항은 11.1.0.7.0 과 동일하다.

또, 11.2 드라이버는 묵시적 명령문 캐시를 활성화 하기 위해서 새로운 속성을 추가한다.

oracle.jdbc.implicitStatementCacheSize

이 속성의 값은 “100” 과 같은 정수형 문자열이다. 이것은 명령문 캐시의 초기(initial) 크기다. 속성을 양수로 지정하면 묵시적 명령문 캐시가 활성화 된다. 기본값은 0 이다. 이 속성은 “-D” 를 통해서 시스템 속성이나 getConnection 을 통한 커넥션 속성으로 지정할 수 있다. OracleConnection.setStatementCacheSize 나 OracleConnection.setImplicitCachingEnabled 를 호출하면 implicitiStateCacheSize 값이 무시된다. 이 속성은 코드로 활성화하는 것이 비실용적인 경우 묵시적 명령문 캐시 활성화를 더 쉽게해 준다.

Oracle Database Release 12.1.0.1.0 Oracle JDBC Drivers

앞에서 설명했듯이, 12.1.0.1.0 드라이버는 다른 메모리 관리 체계를 사용한다. 12c 드라이버는 정의된 컬럼 크기에 민감하지 않다. VARCHAR2(32000) 컬럼은 같은 데이터에 대해 VARCHAR2(1) 보다 메모리를 더 사용하지 않는다. 10i 나 11g 드라이버 처럼, 12c 드라이버는 (쿼리 후 받은 데이터) 결과에서 fetchSize 와 실제 데이터 크기를 더한 컬럼의 수에 민감하다. Oracle 은 스키마 디자인이 다른 시스템 부분에 영향을 줄 수 있기 때문에 신중한 설계를 지속적으로 권장한다. 신중한 쿼리 디자인, 최소한의 컬럼과 로우(row) 세트 검색과 신중한 fetchSize 선택은 그 어떤것보다 중요하다.

12c 드라이버는 버퍼나 버퍼 캐시 크기를 제어하기 위한 옵션을 가지지 않는다. 

어떤 애플리케이션은 쓰레드 수에 비해 아주 많은 idle 커넥션을 가진다. 애플리케이션은 아주 많은 데이터베이스 중에 하나와 연결해야 하지만 오직 한번에 하나만 연결해야 한다. 만약 대략 각 데이터베이스를 위해 쓰레드당 하나의 연결이 있다고 한다면, 쓰레드보다 더 많은 idle 커넥션이 있게 된다. 기본적으로 버퍼 캐시는 커넥션당 이기 때문에 idle 커넥션은 버퍼 캐시에서 비사용 버퍼가 되는 결과가 된다. 이것은 필요 이상으로 많은 메모리가 필요함을 뜻한다. 이것은 비교적 드문 상황이지만, 알려지지 않은 것은 아니다. 

이 경우 커넥션 속성 설정을 통해 해결할 수 있다.

oracle.jdbc.useThreadLocalBufferCache

이 속성의 값은 Boolean 스트링, “true” 이거나 “false” 이다. 기본값은 false 다. 이 속성이 true 일때, 버퍼 캐시는 직접 커넥션을 저장하지 않고 ThreadLocal 에 저장 된다. 만약 커녁션보다 적은 쓰레드만 있다면, 이것은 많은 양의 사용할 메모리를 줄여준다. 이 속성은 -D 를 통한 시스템 속성이나 getConnection 을 통한 연결 속성으로 설정할 수 있다.

useThreadLocalBufferCache = “true” 를 사용하는 모든 커넥션은 같은 정적 ThreadLocal 필드를 공유하며 따라서 같은 버퍼 캐시 세트를 공유한다. 만얄 useThreadLocalBufferCache = “true” 설정되어 있다면, 사용하는 모든 커넥션은 같은 maxCacheBufferSize 를 가진다. 스레드가 처음 하나의 커넥션을 사용한 다음 다른 커넥션을 사용하는 경우 두 커넥션는 사용 된 버퍼의 크기와 수에 따라 서로의 성능에 간접적인 영향을 미친다. 보통 ThreadLocal 버퍼 캐시를 사용하는 모든 커넥션은 같은 애플리케이션의 일부일 것임으로 다른 커넥션을 사용하는 경우의 서로의 성능에 간접적인 영향을 미치는 일은 없다. 만약 한 쓰레드가 명령문을 생성하고 다른 쓰레드가 명령문을 닫는다면, 버퍼는 한개의 ThreadLocal 버퍼 캐시에서 다른 ThreadLocal 버퍼 캐시로 마이그레이션할 것이고 재사용되지 않을 것이다. 이것은 사례로 권장하지 않는다. 만약 모든 명령문이 하나의 ThreadLocal 에서 생성되었고 다른 쓰레드가 닫는다면 전혀 버퍼를 재사용하지 않게 된다. 다시말해 이것은 권장하지 않는다, 만일 여러분의 애플리케이션이 이러한 경우에 속한다면 절대로 useThreadLocalBufferCache 를 true 로 세팅하지 말라. 이것은 어떤 커넥션은 ThreadLocal 버퍼 캐시를 사용하고 어떤 것은 커넥션 버퍼 캐시당 기본값을 사용할 가능성이 있다. 

12c 드라이버는 좀 더 동적인 메모리 관리를 하기 때문에 LONG 및 LONG RAW 컬럼을 메모리로 직접 가져오는 것이 합리적일때가 있다. 만약 여러분의 애플리케이션이 LONG 이나 LONG RAW 에 대한 전체 값을 저장할 충분한 메모리를 가지고 있다면 oracle.jdbc.useFetchSizeWithLongColumn 속성을 설정할 수 있다. 기본적으로, 쿼리가 LONG이나 LONG RAW 컬럼으로 반환하는 경우 드라이버는 fetchSize 를 1로 설정하고 요청시에만 네트워크를 통해서 LONG 나 LONG RAW 값을 읽는다. 만약 이 설정을 설정하면 드라이버는 정의된 fetchSize 를 사용할 것이며 VARCHAR 나 RAW 처럼 전체 LONG 이나 LONG RAW 를 메모리에서 읽는다. LONG 과 LONG RAW 값이 아주 클 수 있기 때문에, 그 값의 크기를 정확하게 메모리에 맞는지를 알지 못한다면 이 설정을 지정해서는 안된다. 만약 이값이 적절하지 않다면 드라이버는 OutOfMemoryException 을 얻을 수 있다. 만일 그것을 저장할 힙(heap) 을 가지고 있다면 메모리에서 읽을 수 있는 가장 큰 단일 값은 2GB 이다.

연결 속성은 

oracle.jdbc.useFetchSizeWithLongColumns

이 값은 Boolean 스트링으로 “true”나 “false” 다. 만약 “true” 이면 LONG 과 LONG RAW 값들은 VARCHAR 과 RAW 값들처럼 메모리에서 읽는다. 기본값 “false” 면 쿼리에서 LONG 이나 LONG RAW 컬럼을 포함해 fetchSize 1 로 강제되고 요청시에만 네트워크를 통해서 LONG 과 LONG RAW 값들을 읽게 된다. 이 속성 역시 “-D” 를 통해서 시스템 속성으로 지정하거나 getConnection 메소드를 통한 연결 속성으로 지정이 가능하다. 주의할 것은 이 속성은 10i, 11g 드라이버에도 존재하지만 잘 사용되지 않는다.

Controlling the Java Heap

자바 런타임 메모리 튜닝은 블랙 아트 영역이다. 가장 중요한 두 가지 옵션은 -Xmx 와 -Xms 다. 자바 런타임 버전 및 OS 에 따라 다른 매개 변수가 있다. -Xmx 는 자바 런타임에서 사용할 최대 힙 크기를 설정한다. -Xms 는 초기 힙 크기를 설정한다. 디폴트 값은 OS 나 자바 런타임에 의존적이지만 대충 기본적으로 -Xmx 는 64MB, -Xms 는 1MB 다. 32 bit JVM 은 2GB 이상의 힙을 지원한다. 64bit JVM 은 아주 큰 힙을 지원할 것이다. 이 옵션들은 “k”, “m”, “g” 의 접미사를 가진 값을 받을 수 있는데, 이것은 kilo-, mega-, gigabytes 다. e.g -Xmx1G

Oracle JDBC 드라이버는 적절한 힙 크기로 실행될때 최고의 성능을 낼 수 있다. 대부분의 애플리케이션의 경우 애플리케이션 힙 크기를 일부 제한으로 늘리면 성능이 향상된다. 그 이후에 제한된 값 이상으로 애플리케이션 힙 크기를 늘려도 성능 차이는 없다. 만약 힙 크기가 머신이 가지고 있는 물리 메모리나 힙 메모리보다 훨씬 크기되면 세컨드 스토리지로 페이지되고 성능은 급격히 나빠질 것이다. 힙 크기를 설정할때, 최대 값 -Xmx 만으로는 출분하지 않다. 특히 11.2 드라이버는 메모리 할당에 그렇게 적극적이지 않다. 빈번하게 실행 가능한 최소값을 초과하여 힙 메모리를 늘리지 않는다. 만약 -Xmx 를 사용해 최대 힙 크기만 지정한다면, 11.2 드라이버는 설사 -Xmx 를 허용했다고 하더라도 최대 성능을 내기위한 충분한 메모리를 결코 사용하지 않는다. 만약 -Xms 를 사용해 최소 힙 크기를 함께 늘리면, 11.2 드라이버는 추가적인 메모리를 사용하게 만들 것이고 자주 최고의 성능을 제공할 것이다. 

애플리케이션 성능 튜닝시에 -Xmx 와 -Xms 모두 설정되고 모두 같은 값으로 설정된 고정된 힙 크기를 가지고 테스트하는 것은 매우 중요하다. JVM 이 힙 크기를 선택하도록 하면 고장된 힙 크기로 명확해진 성능이 모호하게 변화할 수 있다. 일반적으로 프로덕트 애플리케이션은 고정된 힙 크기에서도 잘 동작한다. -server 옵션 설정은 JVM 이 최소화 힙 크기에 대해서 좀 덜 적극적이게 될 것이고 이것은 약간의 성능 향상을 제공한다. -Xms 를 적절하게 설정하면 -server 설정만으로 제공되는 성능 이상으로 추가적인 성능을 제공하는 경우가 종종 있다. Oracle 은 서버 애플리케이션에 대해 -server, -Xms, -Xmx 설정을 권장한다. 보통 -Xms 와 -Xmx 는 같은 값으로 설정한다. 이것은 10i, 11g 그리고 12c 를 포함한 모든 Oracle JDBC 드라이버에 적용된다.

Conclusion

Oracle JDBC 드라이버는 최대 성능을 이룩하기 위해서 많은 양의 메모리를 사용할 수 있다. 만약 메모리가 여러분의 애플리케이션 성능을 제한한다면 최고 성능을 위해서 튜닝할 수 있다. 이상적으로 실제 애플리케이션 워크로드를 대표하는 재현 가능한 테스트 사례가 있어야 한다. 다양한 노브를 체계적으로 변경하고 테스트를 실행하면 최적의 설정을 식별할 수 있다. 모든 버전의 Oracle JDBC 드라이버에 대해, 묵시적 명령문 캐시 활성화, 적절한 데이터베이스 스키마 디자인, 신중한 SQL 코딩 그리고 적절한 fetch 크기 설정이 첫 단계다. 그 다음 Java 힙 크기를 대규모 실제 크기로 설정하기 위해 -Xmx 와 -Xms를 사용해 늘려라. 어떠한 값으로도 수용가능한 성능이 주어지면 -Xms 와 -Xmx 를 줄일 수 있다. 최대의 실제 힙 메모리를 가지고 성능이 원하는 것보다 낮고 10i 나 11g 드라이버를 사용 중이라면 필요에 따라 freeMemoryOnEnterImplictCache 이나 maxCachedBufferSize 를 사용해 실험해야 한다. 이것은 useThreadLocalBufferCache 를 설정해야할지 말지를 여러분의 애플리케이션 설계에서 명확하게 해준다. 만약 여러분이 모든 나머지 성능 영역을 찾고 있다면 자바 가비지 컬렉터 튜닝을 해봐야 겠지만 대부분의 경우 -Xmx 및 -Xms 설정이 필요로 하는 전부다.

HTTP 응답 헤더 보안

의외로 웹 프로그래밍을 하는 사람들 조차도 HTTP 응답 헤더에 대해서 생각을 하지 않는다. HTTP 응답 헤더에 대한 생각을 하지 않는다는 것은 웹 프로그래밍을 깊게 공부한 사람이 아니라고 말할 수도 있다.

Cache Control

대부분의 사람들은 이 부분에 대해서는 잘 안다. Cache Control 헤더는 Client 에 컨텐츠를 어떻게 캐시할 것인지에 대한 제어를 할 수 있다.

하지만 고려해야할 사항이 존재한다. 만약 AWS Cloud 를 사용한다면 더 더욱 고려해야할 사항이 존재한다. AWS 의 CloudFront 는 CDN 서비스로서 컨텐츠 캐시를 기반으로 한다.

만일 특정 컨텐츠에 대해서 캐시를 하고 싶지 않다면 어떻게 해야할까? AWS 에서는 다음과 문서에 기술해 놨다.

사용자 지정 오리진 웹 서버 애플리케이션에서, Cache-Control no-cacheno-store 또는 private 명령을 CloudFront에서 캐시하지 않으려는 객체에 추가합니다. 또는 Expires 명령을 CloudFront에서 캐시하지 않으려는 객체에 추가합니다.

CloudFront에서 특정 파일 캐시를 방지하려면 어떻게 해야 합니까?

오리진(origin) 의 웹 서버나 애플리케이션에서 Cache-Control 헤더를 조작하도록 권고 하고 있다.

위는 응답 캐싱 정책을 정의하는 사용하는 헤더 지시문이다. Cache-Control 은 HTTP/1.1 사양의 일부로 정의 되었다. Expire 는 Cache-Control 이전에 사용했던 지시문이다. 현대의 대부분 브라우저는 HTTP/1.1 를 지원하지만 구형을 쓰는 곳이 있을 수 있음으로 Expire 지시문을 함께 사용한다.

no-cache 는 말그대로 캐시를 하지 말라는 것을 지시한다. 이 지시자를 쓸 경우에 매번 요청할 때마다 문서의 유효성을 검사한다. 그래서 컨텐츠가 변경된 경우에 최신 버전을 가지고 오게 된다. 컨텐츠의 변화를 감지하는 매커니즘을 가진다는 것이 매우 중요하다. 또 모든 것을 캐시를 하지 않는다. 예를들어, 비공계 개인 데이터와같은 것은 이 지시자로 캐시를 제어를 할 수 없다.

no-store 는 비공개 개인 데이터를 포함해 모든 캐시를 하지 않다록 해준다.

public, private 이라는 것도 있다. 이는 중간 캐시를 이용할 경우에 유용하다. 중간 캐시는 CDN 을 의미한다. 만일 CDN 과 같은 중간 캐시 서버가 캐시 데이터를 가지고 있기를 원하지 않는다면 private 를 써야 한다.

그리고 위 코드에 보이는과 같이 모든 것을 다 포함하도록 지시문을 사용해서는 안된다. Pragma, Expire 는 HTTP/1.0 스펙에서 유효하다. 거기다 Cache-Control 지시문에서 no-cache, no-store, max-age 를 한꺼번에 쓰는건 잘못된 것이다.

그래서 cache 전략이 필요하게된다. 이는 HTML 구조를 봐야 한다.

index.html 파일 안에 구조가 저렇게 되어 있다고 가정하면, 대략 다음과 같은 형태의 캐시 전략을 쓸 수 있다.

ContentsCache-Control
index.htmlCache-Control: no-cache
common.cssCache-Control: max-age=86400
a.jsCache-Control: private, max-age=86400

CSS 파일은 최대 1일까지만 캐시하도록 지시했고, Javascript 파일은 CDN 에서 캐시를 하지 못하도록 하고 브라우져에서 최대 1일까지만 캐시하도록 했다. index.html 은 no-cache 를 주어서 캐시를 하지 못하게 했지만 매번 요청할 때마다 변경이 되었는지 체크하고 변경되었다면 최신판을 새로 받도록 했다.

must-revalidate 가 있는데, 강제 사항을 적용할 때 사용 한다. 이는 다음과 같이 사용한다.

이 경우에 1일동안 캐시를 하고 그 이후에는 서버에 반드시 유효성검사를 하도록 강제한다. 만일 네트워크 상황으로 유효성 검사를 못할 경우에는 절대로 캐시 데이터를 사용하지 못하도록 한다.

이론을 기반으로 현실에서 사용 전략을 다음과 같이 세울 수 있다.

경우의 수Cache-Control
금융Cache-Control: no-store
장바구니, 결재 페이지Cache-Control: no-store
개인정보 수정 페이지Cache-Control: no-store
동적 웹 페이지Cache-Control: no-cache
정적 파일Cache-Control: max-age=86400

금융 관련된 웹 애플리케이션을 사용할 때에는 캐시를 되도록이면 하게 하면 안된다.

Nginx 와 같은 경우에 다음과 같이 HTTP Header 에 Cache-Control 을 붙일 수 있다.

Nginx 에서 max-age 설정은 expires 해도 된다. 이렇게 하면 구형의 Expire 지시자도 함께 지정된다.

Spring에서는 Spring-Security 에서 다음과 같이 지원한다.

위 설정은 다음과 같은 상태로 만든다.

만일 직접 캐시를 조작하고 싶다면 다음과 같이 해주면 된다.

Content Type Options

브라우저는 content sniffing 같은 기술을 사용해 다운받을려는 컨텐츠 타입을 추정하고 특정하게 된다. 하지만 이러한 것은 XSS 와 같은 공격을 제공하는 빌미가 된다. 그래서 이것을 방지하기 위해서 다음과 같이 헤더응답을 넣는다.

Spring Security 에서는 간단하게 설정할 수 있다.

HTTP Strict Transport Security(HSTS)

보통 사이트에 접속하는데에 프로토콜을(HTTPS, HTTP) 붙이지 않는다. 이럴 경우 브라우저는 HTTP 로 먼저 접속해보고 서버의 설정에 따라서 HTTPS 로 리다이렉트를 하게 된다.

만일 중간에 해커가 Proxy Server 를 두게되면 클라이언트는 HTTP 로만, Proxy Server 가 이를 받아서 HTTPS 로 뒷단 서버에 연결을 하게된다. 이렇게 되면 모든 정보를 볼 수 있게 된다. 이러한 해킹 기법을 “SSL Stripping” 공격 혹은 SSL/TLS Hijacking 이라고 부른다.

HSTS 는 애초에 접속을 HTTPS 로만 하라고 강제한다. 이는 브라우저와 서버 모두 HSTS 를 모두 지원해야 한다는 제한이 있지만 2010에 HSTS 에 대한 논의로 인해서 현재에는 모든 서버와 브라우저가 지원하고 있다.

HSTS 를 지원하는 브라우저는 도메인 목록을 유지한다. HTTPS 로만 접속 해야만 하는 도메인을 가지고 있게된다. 만일 HSTS 목록에 있는 도메인 주소를 억지로 HTTP 로 접속하게 되면 서버가 리다이렉트를 하는게 아니라 HTTPS 로 다시 접속하라고 브라우저에 요청하게 된다. HSTS 는 목록에 도메인을 유지하는 시간을 지정할 수 있다.

무조건 HTTPS 로만 접속하도록 강제하기 때문에 SSL 도메인 인증서가 있는 사이트에서만 사용 가능하다.

Spring Security 에서는 다음과 같이 간단히 적용할 수 있다.

X-Frame-Options

HTML 내에 또 다른 frame 을 넣는 기술은 자주 사용 되었었다. 최근에는 사용이 줄었지만 그래도 여전히 사용되어지는 기술이다. 하지만 이러한 frame 을 이용할 경우에 그것이 변조에 취약하다는 문제가 있다.

그래서 이 frame 을 실행하지 못하도록 브라우저에게 요청할 수 있는데, 이것이 X-Frame-Options 다. 기본 값은 DENY 이지만 같은 도메인의 frame 일 경우에는 허용할 수도 있다.

Spring Security 에서는 다음과 같이 설정할 수 있다.

SAMEORIGIN 일 경우에는 같은 도메인의 frame 일 경우에는 허용하게 한다.

X-XSS-Protection

XSS 를 브라우저에서 실행하도록 한다. 주의해야할 것은 서버의 웹 애플리케이션에서 하는게 아니라 브라우저의 XSS 필터에서 하는 것이다. 그러니까 서버에 요청을 넣기전에 브라우저가 사전에 XSS를 한번 차단하게 하는 것이다.

Spring Security 에서는 다음과 같이 설정할 수 있다.

CONTENT-SECURITY-POLICY

웹에 자원은 동일한 도메인에서만 작동되도록 설계되었다. 하지만 자신만의 스크립트를 삽입하는 XSS 공격을 고안해 냈다. 이를 방어하기 위해서 고안된 것이 CSP(Content Security Policy) 이다. 이것을 HTTP 헤더에 정의하면 브라우저에는 이곳에서 받은 리소스만 실행허거나 렌더링하도록 강제 한다.

Spring Seuciryt 에서는 다음과 같이 설정할 수 있다.

Spring 에서 기본

많은 웹 애플리케이션이 Spring 을 이용해서 만들어진다. 그리고 인증을 위해서 Spring Security 를 사용한다. 하지만 대부분의 소스를 보면 위에서 언급한 기본적인 보안조차 되어 있지 안되어 있는 곳이 대부분이다. 대기업의 프로젝트에서조차도 이런것을 고려하지도 않는다.

위에서 언급한 모든 내용은 다음과 같이 Spring Security 에서 간단하게 설정할 수 있다.

아주 간단하다. 그냥 가져다 붙여넣기만 해도 된다. 하지만 이것조차도 사용하지 않는 대기업 프로젝트가 부지기수다. 뭐가 기술력이 좋다는 건지… IT 선진국이라는 것이 좋은 인프라에 작동하기만 하면 되는 앱만으로 얻을 수 있는 거였다니..

Helm 설치하기

이 문서는 Kubernetes 의 Helm 설치에 대해 다룬다.

Helm 은 Kubernetes 에서 작동하는 많은 Application 들을 손쉽게 설치하도록 도와주는 프로그램이다. 마치 Ubuntu 의 APT 나 CentOS 의 Yum 이 프로그램 설치를 손쉽게 해주는것과 같다.

Helm

Helm 은 Client – Server 로 구성된다.

Client 는 CLI 명령어를 말하며 플랫폼마다 바이너리로 배포된다. 따라서 다운로드 받아서 압축을 풀면 바로 사용할 수 있다.

Server 는 Tiller 라고 불리운다. 이것은 Kubernetes 상에서 작동되는데 Deploy 해서 설치하면 된다.

Helm Client

Helm 클라이언트는 GitHub 에서 다운로드가 가능하다.

다음과 같이 설치가 잘되었는지 확인한다.

Helm Server – Tiller

Tiller 를 설치하기 위해서 서비스 계정을 생성하고 cluster-admin Role 을 생성해 준다. 이는 CLI 로 생성하거나 Yaml 을 이용해서 생성해도 된다.

파일을 작성해 다음과 같이 적용해 준다.

이제 Tiller 를 설치해 준다.

이제 다시 helm client 를 실행해보자.

이제 helm 의 저장소를 최신판으로 업데이트를 해보자.

Metric Server 설치하기

Kubernetes 를 설치하게 되면 자원에 대한 모니터링이 필요하다. 과거에는 Heapster 를 이용했지만 이것은 이제 더 이상 개발이 되지 않고 있으며 이를 대체하는 것이 Metric Server 이다.

Kubernetes 에서 뭔가를 설치하는 것은 대부분 Pods 를 설치하는 것이며 이것에 대한 Rules, Datastore 등도 한꺼번에 설정을 해준다.

Metric Server 를 설치하게 되면 Kubernetes 의 컴포넌트들에 대한 자원 모니터링이 가능해지며 이것을 이용해 Autoscaling 에도 사용이 가능해진다.

Downloads

Metric Server 를 다음과 같이 다운로드를 한다.

2020.04.19 현 시점에서 v0.3.7 이 있지만 ErrorImagePull 에러가 발생하면서 설치가 진행되지 않는다. 따라서 v0.3.6 으로 설치한다.

TLS 수정

Metric Server 를 설치할때에 주의해야 할 것은 Kube API 서버와의 통신에서 사용할 TLS 를 수정하는 것이다. Metric Server 는 Public TLS 를 기본으로 하지만 Kube API 는 Kube 자체의 TLS 를 사용하기 때문에 그냥 설치하면 문제가 된다.

Deploy

이제 이것을 Deploy 해준다. Kubernetes 에서는 설치라는게 없다. 모두 다 pods 로 다 올라가기 때문에 Deploy 라고 한다.

위와같이 관련된 설정과 pods, deploy, service 등이 생성이 된다.

확인

Metric Server 의 확인은 pods, deploy 가 제대로 되었는지를 살펴보면 된다.

그리고 1~2분을 기다리면 후에 다음과 같이 자원이 출력이 되는지를 보면 된다.

CPU, Memory 등과 같은 자원 현황이 출력이 되면 정상적으로 작동하는 것이다.

Grafana admin password reset

Grafana 는 Time series 데이터베이스에 내용을 그래프로 그려주는 유명한 웹 프로그램이다. 아주 유용한 프로그램으로 인기가 높다.

그런데, 이것을 사용하다가 admin 패스워드를 잊어버렸다면 어떻게 해야할까? 공식 메뉴얼에는 다음과 같이 하라고 나와 있다.

하지만 이렇게 해도 되지 않는다. 이럴때는 다음과 같이 하면 된다.

위 내용은 admin 계정의 패스워드를 ‘admin’ 으로 초기화 시키는 것이다. Grafana 에 접속해 초기화 패스워드를 입력하면 새로운 패스워드를 지정하라는 프로세스를 타게 된다.

Nginx 액세스 로그를 CloudWatch Logs Agent 로 보내기

이 글은 다음의 글을 번역한 것입니다. 저작권은 원작자에게 있습니다.

최근에 나는 Ubuntu 18.04 에서 CloudWatch Logs 를 어떻게 설정하는지에 대한 글을 썼다. 그 글에서 나는 Agent 가 */var/log/syslog* 를 CloudWatch Logs로 syslog log 파일을 푸쉬하도록 설정했다. 이전 글을 보고 여기로 오길 바라고 혹시나 여러분이 Ubuntu 를 사용하지 않는다면 여러분이 사용하는 OS 에 CloudWatch Logs Agent 를 설치하기 위해서 AWS 문서를 체크해야 한다.

여기서 나는 Nginx 의 액세스 로그(access log) 와 에러 로그(Error log) 를 AWS CloudWatch Logs Agent 를 통해서 CloudWatch Logs 로 어떻게 전송하는지를 보여줄 것이다.

우리는 에이전트가 소비하기 원하는 두개의 Nginx 로그 파일을 가진다고 가정하자: */var/log/nginx/access.log**/var/log/nginx/error.log* 로 원하는 만큼 많은 Nginx 로그를 추가할 수 있다.

AWS CloudWatch Logs Agent 는 *amazon-cloudwatch-agent.json* 파일로부터 설정들을 가지고 오고 이것은 Ubuntu 에서 */opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json* 위치해 있다.

이미 파일이 그곳에 있을거라 생각하고 collect_list 배열 아래쪽에 다음을 추가하면 된다.

여기서 핵심은 Nginx 로그 파일에서 timestamp_format 과 일치하는 포맷을 찾는다는 것이고, 만약 Ubuntu 에서 Nginx 에 기본 로깅 설정을 사용중이라면 위 설정은 잘 맞는다.

또 log_group_name 이 CloudWatch Logs Agent 의 자격증명에 로그 스트림 생성을 위한 logs:CreateLogSteam, 로그 스트림 기술을 위한 logs:DescribeLogStream 그리고 로그 이벤트를 푸쉬하기 위한 logs:PutLogEvents 의 IAM 허가권을 가지는 로그 그룹과 일치하는지 확인해봐야 한다.

amazon-cloudwatch-agent.json 파일을 업로드 한 후에 agent 서비스를 재시작해줄 필요가 있다:

곧바로 CloudWatch Logs 에서 Nginx 로그들이 표시된다.

Ubuntu 18.04 LTS 에 CloudWatch Logs Agent 설정하기

이 글은 다음의 글을 번역한 것입니다. 저작권은 원작자에게 있습니다.

AWS CloudWatch Logs Agent 는 서버로부터 AWS CloudWatch Logs 서버로 로그를 전송하기 위해 설정될 수 있다. 이 문서에서, 나는 어떻게 Ubuntu 18.04 LTS 에 어떻게 설정하는지 보여줄 것이지만 여러분은 Ubuntu16.04 혹은 다른 운영체제 에서도 유사한 절차를 따를 수 있다. CloudWatch Logs Agent 는 Windows Servers 에서 EventViewer 로그를 수집하기 위해 설정할 수도 있다.

아주 좋은것은 여러분이 AWS EC2 를 실행하지 않는다고 하더라도, Azure, Google Cloud, Linode, Digistal Ocean 등과 같이 어떤 서버든지 이 기술을 사용할 수 있다는 점이다. 이 문서는 여러분이 따라하기에 쉬운 간단한 샘플이다.

여러분은 이러한 절차를 설정관리 스크립트로 손쉽게 만들거나 자신만의 Docker 이미지 사용을 위해 Dockerfile에 추가할 수 있어야 한다.

Download / Install the Debian Package

AWS 는 그들의 문서에 CloudWatch Logs Agent 데미안 패키지 위치를 기술하고 있고 우리는 curl 을 이용해 다운로드하고 실행하면 된다.

이 문서의 모든 명령어는 sudo 를 사용허거나 root 사용자로 실행하는 것으로 한다.

Add cwagent User to adm group

다음으로 우리는 설치 프로그램이 생성한 cwagent 리눅스 사용자 계정을 Ubuntu 시스템 로그들에 읽기 허가권을 주기 위해서 adm 그룹에 추가하는 수정작업을 할 것이다.

Setup an IAM User Account and Permissions

이제 우리는 여러분의 AWS 계정에 CloudWatch Logs 에 로그 데이터를 전송하기 위해 Ubuntu 서버에 허가권을 부여할 필요가 있다.

만약 AWS EC2 운영하고 있다면, 이 과정을 건너뛰고 Assumed Role 를 사용해라. 하지만 IAM 허가권을 가진 Assumed Role 이 있는지 확인할 필요가 있다.

AWS Console 에서 IAM 사용자를 생성하고 AWS accessID 와 AWS secretKey 를 기록하고 여러분의 Ubuntu 서버에서 다음과 같이 /home/cwagent/.aws/credentials 파일을 생성하십시오.

또, 다음과 같이 /home/cwagent/.aws/config 파일을 생성하십시오

AWS console 에서 만든 새로운 IAM user 의 aws_access_key_id 와 aws_secret_access_key 를 사용해야 해야하며 region 또한 정확하게 지정해야 한다. 다음과 같이 /opt/aws/amazon-cloudwatch-agent/etc/common-config.toml 에 추가함으로써 인증을 위해 CloudWatch Logs Agent 가 여기를 바라보도록 한다.

Create a Log Group

어떻게 로그들을 구성하길 원하는지에 대해서 잠깐 동안 생각해봐야 한다. CloudWatch Logs 는 Log Groups 과 Logs Streams 개념을 제공한다. 로그 그룹을 로그별로 다이나믹하게 생성하거나 하나의 로그 그룹에 모든 서버 로그들을 사용할지와 같은 것이다. 이 문서에서 우리는 hostname.example.com/syslog 와 같은 로그 스트림을 생성하는 여러 서버에 대한 로그를 가질 수있는 하나의 로그 그룹을(web-server-log-group) 생성할 것이다.

나는 단일 로그 그룹에 스트림을 생성하고 로그를 출판하기 위한 접근만 제공하기 위해 IAM 허가권을 제한할 수 있기 때문에 이러한 접근방법을 선호한다.

Grant the IAM User / Role Permission to Publish Logs

web-server-log-group 으로 명명된 로그 그룹을 가지고 있다고 가정하고 이전 절차에서 생성한 IAM user에 IAM 정책(Policy) 를 붙일 것이다. 만약 EC2 를 운영중이라면 Assumed Role 에 이 정책을 붙일 수 있다.

주의해야 할 것은 숫자 1234567890 는 여러분의 AWS account id 로 바꿔야 한다. 만약 CPU, Memory, Network, Disk 와 같은 서버 메트릭 데이터를 CloudWatch Logs Agents 가 출판하길 원한다면 다음과 같이 cloudwatch:PutMetricData 허용을 위해 추가적인 정책을 붙일 필요가 있다.

나도 리소스(Resource)에 대해 와이들카드(*) 를 사용하는 대신에 좀더 제한적일 수 있는지 좀 더 찾아봐야 한다.

또, AWS 는 여러분이 사용할 수 있도록 CloudWatchAgentServerPolicy 으로 명명된 이미 만들어진 정책을 제공한다. 하지만 개인적으로 이건 조금 과도한 허가권이라 생각한다. 이것은 Agent 가 새로은 로그 그룹과 모든 로그 그룹에 로그를 출판하도록 서버에 허가한다.

Telling CloudWatch Logs Agent Which Log Files to Collect

AWS CloudWatch Logs Agent 는 위자드(Wizard) 를 통해서 json 설정 파일 생성을 위해 실행할 수 있는 툴을 가지고 있다:

아니면 이 위치에: /opt/aws/amazon-cloudwatch-agent/etc/amazon-cloudwatch-agent.json 수동으로 JSON 파일을 생성할 수 있는데 다음과 같다.

이것은 Ubuntu 서버의 /var/log/syslog 의 내용을 AWS CloudWatch Logs 서비스로 출판 한다. 여기에 nginx 로그를 CloudWatch Logs로 전송하는 예제가 있다.

Enable and Start the CloudWatch Logs Agent service

마지만 단계로 AWS CloudWatch Logs Ubuntu 서비스를 활성화 해주고 서비스를 시작해준다. 이것은 다음의 두개 명령어로 실행할 수 있다.

AWS CDK 개발 환경 구축하기

이 문서는 AWS CDK 개발 환경 구축에 대한 글이다. AWS CDK 는 코드로 AWS 자원을 관리하게 해주는 것으로 Infrastructure As Code 에 부합한다. 이를 사용하기 위해서는 환경 구축이 필수이기에 이를 기록한다.

구축 환경

AWS CDK 는 몇가지 언어를 지원 한다. 나는 Python 을 사용할 것임으로 Python 관련된 설정도 필수다. 그런데, Python 을 사용해보면 알겠지만 Windows 플랫폼 보다는 Unix 스타일의 플랫폼이 적합하다는 것을 알게 된다. 따라서 구축 환경은 다음과 같이 정했다.

  • OS: Mint Linux 19.3 Tricia XFCE
  • Python3

한가지 더 있다. Python3 을 사용할 경우에 AWS SDK 등을 모두 설치해야 한다. 하지만 Python 은 캡슐화를 지원한다. Virtualenv 가 바로 그것인데, 모든 것을 Virtualenv 환경으로 구축을 할 예정이다.

PreRequirement

이제 본격적으로 구축을 해보자. 이를 위해서 필수 프로그램이 필요한데, 이는 다음과 같다.

  • npm (Node)

이는 다음의 URL 을 명시되어 있다.

Node, npm 설치

npm 을 기반으로 한다고 문서에 나와 있다. 따라서 npm 을 설치해 줘야 한다. npm 은 Node.js 기반이며 Node.js 를 설치하는 방법은 다양하지만 이전에 이에 대해서 기술한 문서가 이미 있기에 다음을 참고 했다.

주의할 것은 AWS 의 문서에 나와 있다시피 LTS 버전을 설치해줘야 한다. AWS 문서에 나와 있듯이 CDK 를 설치해 준다.

Python3 환경 구축

Python3 에도 필요한 것이 있는데, distutils 패키지 이다. 이것은 우분투 패키지로 설치를 해줘야 한다. 다음과 같이 설치를 해준다.

이것을 설치해야지만 python3 을 로컬 계정에서 환경을 구축할 수 있다. 다음과 같이 pip 를 설치해 준다.

virtualenv 를 설치하고 난 후에 이제 캡슐환경을 만들어준다. 그냥 .python3 으로 만들어준다.

여기서 이제 AWS CLI 와 기타 몇가지를 함께 설치해준다. 이는 Python3 에 패키지로 존재함으로 pip 명령어를 이용해서 설치하면 된다.

이로써 필수 프로그램 설치는 다 됐다.

VS Code 설정

이제 Editor 설정을 해야 한다. VS Code 라면 AWS CDK 를 사용하는데 부족함이 없다. 데스크탑 리눅스를 사용함으로 VS Code 에서 우분투 패키지를 다운로드해 설치하면 된다.

Color Themes

좋은 Color Themes 가독성을 높여줘 프로그래밍을 하는데 많은 도움이 된다. 내가 주로 사용하는 Color Themes 는 다음과 같다.

  • Ayu
  • Primal

물론, 이건 지극히 개인적인 것임으로 검색을 통해서 자신에게 맞는 Color Themes 를 찾으면 된다.

Python Extension 설정

VS Code 가 Python 을 지원하도록 해야 한다. 이를 위해서 Python Extension 을 설치하고 다음과 같이 설정을 해준다. 그리고 다음과 같이 pip 를 이용해서 프로그램을 설치해준다.

AWS Toolkit for Visual Studio Code

AWS Tookit Extension 을 설치해 준다. 별도의 설정은 해주지 않아도 된다.

Indenticator, indent-rainbow

Python, Yaml 문법의 특성상 Indent 를 기반으로 문법 체크를 하는데 이 Extension이 도움이 된다.

Sort lines

라인을 알파벳 순, 숫자순으로 정렬을 해준다.

vscode-cfn-lint

cfn 는 CloudFormation 을 말한다. CloudFormation 문법을 체크해 준다.

YAML Support by Red Hat

CloudFormation 은 YAML 문법을 따른다. 이 문법을 체크해 준다.

Cloudformation YAML snippets for VS Code

코딩을 할때에 필요한 코드 조작을 넣어준다.

Better Comments

주석에 색깔을 입혀서 가독성을 높여준다.

이렇게 설치한 Extension 에 대한 설정값은 다음과 같다.

AWS Credential 세팅

Python3 에 가상환경에서 aws configure 명령어를 이용해서 접속을 위한 credential 을 만들어준다.

이로써 AWS CDK 를 위한 VS Code 설정을 기술했다. 정답은 없다. 개인적으로 사용하는 설정을 기반으로 보다 좋은 방법, 환경을 위한 설정이 있을 것이다.

Node 설치하기

Node.js 줄여서 Node 는 브라우저에서 탑재되었던 Javascript 엔진을 독립된 애플리케이션으로 만들어 Javascript 를 이용해 애플리케이션을 작성할 수 있도록 해준다.

준비

모르긴 몰라도 Javascript 만큼이나 다이나믹하고 빠르게 변화를 수용하는 언어를 찾기는 쉽지 않다. 그러다보니 이를 지원하는 Node.js 도 다양한 버전이 존재하게 되는데 이러한 다양한 버전을 관리하기 위한 별도의 툴이 필요하게 되었던 모양이다.

Node Version Manager (NVM). Node.js 의 버전을 관리하기 위한 툴로서 이를 이용하면 다양한 버전의 Node.js 를 설치하고 관리할 수 있게 된다.

Node.js 설치는 NVM 을 사용해 할 것이다.

NVM 설치

NVM 의 장점은 대략 다음과 같다.

  • 간단한 명령어로 로컬 계정에 설치가 가능하다.
  • 다양한 버전의 Node.js 를 쉽게 교체 가능하다.
  • Default 버전을 alias 를 통해서 간단하게 지정이 가능하다.

다음과 같이 설치 쉘 스크립트를 다운로드해 실행함으로써 설치는 끝난다.

설치가 끝나면 로그인을 새로하거나 다른 로그인 세션을 열면 된다.

설치가 정상적으로 되었다면 다음과 같이 확인해 볼 수 있다.

Node.js 설치

NVM 을 설치했다면 Node.js 설치는 매우 쉽다.

확인은 역시 버전을 통해서 가능하다.

간단 NVM 사용 방법

NVM 이 설치한 Node.js 를 비롯한 컴포넌트들을 확인하기 위해서는 다음과 같하면 된다.

Node.js 역시 Long Term Support 버전을 지원한다. 이 버전을 설치하기 위해서는 다음과 같이 하면 된다.

이렇게 하면 default 값이 v12.14.1 로 변경된다. 확은은 nvm ls 명령어를 이용한다.

사용하고자하는 버전으로 변경하고 싶다면 use 를 사용하면 된다.

Reactive Stream 간단 사용

Reactive Stream 을 사용하기 위해서는 다음과 같은 것을 구현해줘야 한다.

  • Publisher
  • Subscriber
  • Subscription

한가지 문제가 있다. 이것을 구현하기가 쉽지가 않다. 특히 Publisher 의 경우에는 Reactive Stream 의 기본 아이디어만 가지고 간단하게 구현할 수가 없다. 어떤 것을 Publisher 할지도 영향을 주는것도 문제지만 Reactive 의 Spec 을 마춰짜야 하는데 이게 쉽지가 안다.

Publisher 를 간단하게 구현 방법이 없을까? SubmissionPublisher 를 이용하면 간단하게 사용해 볼 수 있다.

이 문서는 SubmissionPublisher 를 이용해 어떻게 Reactive Stream 을 구현하는지를 설명한다.

SubmissionPublisher Class

이 클래스를 간단히 살펴보자.

이 클래스는 Publisher 인터페이스를 구현한 구현체 클래스 이다. 하지만 아주 간단하지만은 않다.

SubmissionPublisher 클래스가 가지는 메소드가 꽤 있다. 자세히 보면 get 혹은 is 로 시작하는 메소드가 많음을 알 수 있다. 이 클래스들은 Publisher 의 상태 정보를 체크하기 위한 것들이다. 반대로 set 으로 시작하는, 그러니까 뭔가를 지정하는 메소드는 많지가 않다.

이 클래스에 설명은 다음과 같이 시작한다.

Flow.Publisher that asynchronously issues submitted (non-null) items to current subscribers until it is closed. Each current subscriber receives newly submitted items in the same order unless drops or exceptions are encountered. Using a SubmissionPublisher allows item generators to act as compliant reactive-streams Publishers relying on drop handling and/or blocking for flow control.

Flow.Publisher 는 Null 이 아닌 제출된 아이템들을(item) 현재 구독자에게 닫힐때까지 비동기적으로 발행한다. 각각의 현재 구독자들은 삭제 또는 예외가 발생하지 않는한 새롭게 제출된 아이템들을 같은 순서로 받는다. SubmissionPublisher 를 사용하는 것은 아이템 생성기를 흐름제어를 위해 삭제 핸들링과 블럭킹을 필요로하는 reactive-streams Publisher 와 호환되는 것처럼 행동하게 해준다.

https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/SubmissionPublisher.html

어찌되었든 간에 이것을 이용하면 Reactive Streams Publisher 처럼 만들어 준다 것에 주목해야 한다.

SubmissionPublisher 사용하기

사용방법은 아주 간단하다.

SubmissionPublisher 의 객체를 하나 생성한다. 그리고 Reactive Stream 이 Publisher 에 요구하는 subscribe 메소드를 호출해 준다.

하지만 subscribe() 메소드는 인자값으로 Subscriber 클래스를 요구한다. Subscriber 클래스는 Interface 클래스여서 구현체 클래서를 넣어야 한다. 다양한 방법이 있지만 여기서는 다음과 같이 작성해 본다.

Reactive Stream 이 요구하는 Subscriber 에 요구 메소드들이(onNext, onError, onComplete) 모두 나온다. 다음과 같이 모두 구현해 준다.

위와같이 구현을 해주면 된다. 여기서 중요한 것이 존재하는데, Subscription 객체 변수를 반드시 써야 한다는 것이다. onSubscribe, onNext 메소드에서 공통으로 보이는 subscription.request(1) 이 바로 그것인데 onNext 메소드에 이를 사용하기 위해서 Subscriber 구현체에서 멤버변수를 만들어두고 onSubscribe 시에 주입된 객체변수를 할당해 준다.

이제 다음과 같이 publisher 의 submit 메소드를 사용해 아이템을 넣어준다.

submit 메소드는 아이템을 제출해 비동기적으로 Subscriber 에게 생성해준다. SubmissionPublisher 의 비동기는 Thread 를 이용한다. 그래서 모든 Thread 가 완료되기를 Main Thread 를 몇초간 중지줘야해서 Thread.sleep(100) 코드가 필요하다.

모든 비동기 제출이 완료되면 제출자를 닫아준다. publisher.close() 다.

이렇게 완료된 전체 코드는 다음과 같다.

Reactive Stream 을 어떻게하면 간단하게 사용해볼까. Reactive Stream 이 요구하는 최소사항을 어떻게하면 직접 사용해볼 수 있을까? 그렇다면 SubmissionPublisher 클래스를 활용하라.