> For the complete documentation index, see [llms.txt](https://docs.tibero.com/technical-guides/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.tibero.com/technical-guides/topics/installation/docker-image.md).

# Tibero 도커 이미지 가이드

독립적인 가상화 환경을 생성하는 도커 플랫폼의 이미지를 활용함으로써 더욱 편리하고 안정적으로 Tibero를 설치하는 방법을 안내합니다.

## 1. 도커 이미지 사용

아래 두 가지 방법 중 적합한 방식으로 도커 이미지를 사용합니다.

* [공식 도커 이미지 사용](#undefined)
* [도커 이미지 커스텀 생성](#undefined-1)

### 공식 도커 이미지 사용

아래 경로에서 Tibero 공식 도커 이미지를 다운로드 합니다.

> **Tibero 공식 도커 이미지 다운로드**
>
> <https://hub.docker.com/r/tiberoofficial/tibero>
>
> * Tibero 7 패치셋 버전 업데이트

### 도커 이미지 커스텀 생성

#### 1. Tibero 바이너리 준비

적합한 바이너리를 다운로드 받아 tibero.tar.gz 파일명으로 변경합니다.\
Dockerfile 과 동일한 경로에 바이너리 파일을 위치합니다.

#### 2. Dockerfile 준비

도커 이미지 빌드를 위해 도커파일(Dockerfile)을 생성합니다.

아래 예시는 rockylinux9 을 사용합니다.\
준비한 티베로 바이너리의 Major 버전으로 TB\_VERSION 을 수정합니다.

```docker
FROM rockylinux:9

# Tibero 설치를 위한 환경 변수 설정
ENV TB_VERSION=7
ENV TB_BASE=/opt
ENV TB_HOME=$TB_BASE/tibero$TB_VERSION
ENV LD_LIBRARY_PATH=$TB_HOME/lib:$TB_HOME/client/lib
ENV PATH=$PATH:$TB_HOME/bin:$TB_HOME/client/bin

# Tibero 바이너리 파일 복사
COPY tibero.tar.gz /tmp/tibero.tar.gz

# 필수 패키지 설치
COPY ./scripts/install_dependency.sh /opt/install_dependency.sh
RUN chmod +x /opt/install_dependency.sh
RUN /opt/install_dependency.sh


# Tibero 설치
COPY ./scripts/install_tibero.sh /opt/install_tibero.sh
RUN chmod +x /opt/install_tibero.sh

# Entrypoint 스크립트 복사 및 권한 설정
COPY ./scripts/entrypoint.sh /opt/entrypoint.sh
RUN chmod +x /opt/entrypoint.sh

ENTRYPOINT ["/opt/entrypoint.sh"]
```

#### 3. 스크립트 생성

#### 의존성 패키지 설치 스크립트

컨테이너 이미지에 필요한 패키지를 설치하는 스크립트입니다.&#x20;

필요한 패키지가 있다면 스크립트에 추가합니다. \
Dockerfile 과 같은 경로의 scripts 디렉토리 내 install\_dependency.sh 파일명으로 생성합니다.

```bash
#!/bin/bash
set -e

# Install dependencies for Tibero
dnf update -y

dnf install -y gcc
dnf install -y gcc-c++
dnf install -y libaio
dnf install -y libaio-devel
dnf install -y sysstat
dnf install -y glibc-utils
dnf install -y ncurses-devel
dnf install -y libnsl
dnf install -y libnsl2
dnf install -y gdb
dnf install -y gdb-doc
dnf install -y gdb-gdbserver
dnf install -y gdb-headless
dnf install -y gdb-minimal
dnf install -y gdbm-libs
dnf install -y tar
dnf install -y vim
dnf install -y vi
dnf install -y hostname

# Tibero process 확인용 (pgrep)
dnf install -y procps-ng

dnf clean all


curl -O https://dl.fedoraproject.org/pub/epel/epel-release-latest-9.noarch.rpm
rpm -ivh epel-release-latest-9.noarch.rpm

dnf install -y nmon
dnf install -y java-1.8.0-openjdk-devel
dnf install -y ncurses-compat-libs

ln -s /usr/lib64/libncurses.so.6.2 /usr/lib64/libncurses.so.5 || true
ln -s /usr/lib64/libtinfo.so.6.2 /usr/lib64/libtinfo.so.5 || true
ln -s /usr/lib64/libform.so.6.2 /usr/lib64/libform.so.5 || true
```

#### 엔트리포인트 스크립트

Dockerfile에 작성한 ENTRYPOINT 로 컨테이너 생성, 재시작 시 수행되는 스크립트입니다.\
Dockerfile 과 같은 경로의 scripts 디렉토리 내 entrypoint.sh 파일명으로 생성합니다.

```bash
#!/usr/bin/env bash
set -euo pipefail

# BOOT_POLICY=auto(기본) | manual
: "${BOOT_POLICY:=auto}"
: "${INSTALL_TGZ:=/tmp/tibero.tar.gz}"
: "${TB_PROC:=tbsvr}"          # Tibero 메인 프로세스명
: "${TB_START_CMD:=tbboot}"    # Tibero 기동 명령
: "${TB_DOWN_CMD:=tbdown}"     # Tibero 종료 명령

if [ -f /etc/bashrc ]; then
  set +u
  # /etc/bashrc 내부에서 BASHRCSOURCED를 사용할 수 있으므로 기본값 보장
  : "${BASHRCSOURCED:=0}"
  source /etc/bashrc || true
  set -u
fi

if [ -f "${HOME}/.bashrc" ]; then
  set +u
  : "${BASHRCSOURCED:=0}"
  source "${HOME}/.bashrc" || true
  set -u
fi

graceful_shutdown() {
  echo "[signal] Shutting down database (if running)..."
  ${TB_DOWN_CMD} immediate >/dev/null 2>&1 || true
  exit 0
}
trap graceful_shutdown SIGINT SIGTERM

# ===== 수동 모드: 설치/기동 모두 생략, 컨테이너만 유지 =======================
if [[ "${BOOT_POLICY}" == "manual" ]]; then
  echo "[mode] BOOT_POLICY=manual → skip install/boot. keeping container alive."
  echo "[note] even if ${INSTALL_TGZ} exists, will NOT install. will NOT run tbboot."
  # 컨테이너 생존 유지
  exec sleep infinity
fi

# ===== 자동 모드: 설치 및 기동 시도 ==========================================
# 1) 최초 생성 판단: tar.gz 존재시 설치 시도
if [ -f "${INSTALL_TGZ}" ]; then
  echo "[init] Found ${INSTALL_TGZ} → running /opt/install_tibero.sh ..."
  /opt/install_tibero.sh
fi

# 2) 서버 기동 시도
if ! pgrep "${TB_PROC}" >/dev/null 2>&1; then
  echo "[start] Starting Tibero..."
  if ! ${TB_START_CMD} >/dev/null 2>&1; then
    echo "[error] Failed to start Tibero (${TB_START_CMD}). Check logs."
    exit 1
  fi
fi

# 3) 기동 검증
if pgrep "${TB_PROC}" >/dev/null 2>&1; then
  echo "#########################"
  echo "Tibero is Ready To Use!"
  echo "#########################"
else
  echo "[error] Tibero process not found after start attempt."
  exit 1
fi

# 4) 컨테이너 생존 유지 (로그 tail이 필요 없으면 단순 sleep으로 유지)
exec sleep infinity
```

#### Tibero  설치 스크립트

Tibero  설치 스크립트로 바이너리 내 tb\_create\_db.sh 를 사용합니다.\
Dockerfile 과 같은 경로의 scripts 디렉토리 내 install\_tibero.sh 파일명으로 생성합니다.

```bash
#!/bin/bash
set -e

if [ -f "/tmp/tibero.tar.gz" ]; then
  : "${TB_BASE:?TB_BASE is required}"
  mkdir -p "${TB_BASE}"
  tar -xzf "/tmp/tibero.tar.gz" -C "${TB_BASE}" && rm -f "/tmp/tibero.tar.gz"
  chmod -R 775 $TB_HOME
fi
echo "10% complete"

echo "Setting Environment Variables"

if [[ -n "${TB_USER_FILE:-}" && -f "${TB_USER_FILE}" ]]; then
  TB_USER="$(< "${TB_USER_FILE}")"
  export TB_USER
fi

if [[ -n "${TB_PASSWORD_FILE:-}" && -f "${TB_PASSWORD_FILE}" ]]; then
  TB_PASSWORD="$(< "${TB_PASSWORD_FILE}")"
  export TB_PASSWORD
fi

# 루트 패스워드 필수
if [[ -z "${TB_ROOT_PASSWORD:-}" ]]; then
  echo "[ERROR] TB_ROOT_PASSWORD environment variable is not set. Exiting." >&2
  exit 1
fi
if [[ -n "${TB_ROOT_PASSWORD_FILE:-}" && -f "${TB_ROOT_PASSWORD_FILE}" ]]; then
  TB_ROOT_PASSWORD="$(< "${TB_ROOT_PASSWORD_FILE}")"
  export TB_ROOT_PASSWORD
fi

: "${TB_HOME:?TB_HOME is required}"
if [ -f "${TB_HOME}/bin/base_env.sh" ]; then
  sed -i "s|^svr_sys_password=\"tibero\"$|svr_sys_password=\"${TB_ROOT_PASSWORD}\"|" \
    "${TB_HOME}/bin/base_env.sh"
fi

: "${TB_SID:=tibero}"
export TB_SID
echo "export TB_VERSION=\"${TB_VERSION}\"" >> "${HOME}/.bashrc"
echo "export TB_BASE=\"${TB_BASE}\"" >> "${HOME}/.bashrc"
echo "export TB_HOME=\"${TB_HOME}\"" >> "${HOME}/.bashrc"
echo "export LD_LIBRARY_PATH=\"${LD_LIBRARY_PATH}\"" >> "${HOME}/.bashrc"
echo "export PATH=\"${PATH}\"" >> "${HOME}/.bashrc"
echo "export TB_SID=\"${TB_SID}\"" >> "${HOME}/.bashrc"

echo "20% complete"


# Generating Tip file
echo "Generating tip file"
TIP_FILE_PATH=${TB_HOME}/config/${TB_SID}.tip

"${TB_HOME}/config/gen_tip.sh" -s "${TB_SID}"

# LOG_ARCHIVE_DEST 반영 (있으면 교체, 없으면 추가)
if [ -n "${LOG_ARCHIVE_DEST:-}" ]; then
  if grep -q "^LOG_ARCHIVE_DEST=" "${TIP_FILE_PATH}"; then
    sed -i "s|^LOG_ARCHIVE_DEST=.*|LOG_ARCHIVE_DEST=${LOG_ARCHIVE_DEST}|" "${TIP_FILE_PATH}"
  else
    printf "\nLOG_ARCHIVE_DEST=%s\n" "${LOG_ARCHIVE_DEST}" >> "${TIP_FILE_PATH}"
  fi
fi

echo "30% complete"

# # Setting DB Create environment variables
args=()
[ -n "$CHAR_SET" ] && args+=("-ch" "$CHAR_SET")
[ -n "$NCHAR_SET" ] && args+=("-nch" "$NCHAR_SET")
[ -n "$MAX_DATAFILE" ] && args+=("--max-datafile" "$MAX_DATAFILE")
[ -n "$MAX_LOGGROUP" ] && args+=("--max-loggroup" "$MAX_LOGGROUP")
[ -n "$MAX_LOGMEMBER" ] && args+=("--max-logmember" "$MAX_LOGMEMBER")
[ -n "$LOG_SIZE" ] && args+=("--log-size" "$LOG_SIZE")
[ -n "$LOG_GROUP" ] && args+=("--log-group" "$LOG_GROUP")
[ -n "$LOG_FILE" ] && args+=("--log-file" "$LOG_FILE")
[ -n "$LOG_DIR" ] && args+=("--log-dir" "$LOG_DIR")
[ -n "$SYS_SIZE" ] && args+=("--sys-size" "$SYS_SIZE")
[ -n "$SYS_DIR" ] && args+=("--sys-dir" "$SYS_DIR")
[ -n "$SYS_AUTOEXTEND" ] && args+=("--sys-autoextend" "$SYS_AUTOEXTEND")
[ -n "$SYS_NEXTSIZE" ] && args+=("--sys-nextsize" "$SYS_NEXTSIZE")
[ -n "$SYS_MAXSIZE" ] && args+=("--sys-maxsize" "$SYS_MAXSIZE")
[ -n "$TEMP_SIZE" ] && args+=("--temp-size" "$TEMP_SIZE")
[ -n "$TEMP_DIR" ] && args+=("--temp-dir" "$TEMP_DIR")
[ -n "$TEMP_AUTOEXTEND" ] && args+=("--temp-autoextend" "$TEMP_AUTOEXTEND")
[ -n "$TEMP_NEXTSIZE" ] && args+=("--temp-nextsize" "$TEMP_NEXTSIZE")
[ -n "$TEMP_MAXSIZE" ] && args+=("--temp-maxsize" "$TEMP_MAXSIZE")
[ -n "$UNDO_SIZE" ] && args+=("--undo-size" "$UNDO_SIZE")
[ -n "$UNDO_DIR" ] && args+=("--undo-dir" "$UNDO_DIR")
[ -n "$UNDO_AUTOEXTEND" ] && args+=("--undo-autoextend" "$UNDO_AUTOEXTEND")
[ -n "$UNDO_NEXTSIZE" ] && args+=("--undo-nextsize" "$UNDO_NEXTSIZE")
[ -n "$UNDO_MAXSIZE" ] && args+=("--undo-maxsize" "$UNDO_MAXSIZE")
[ -n "$USR_SIZE" ] && args+=("--usr-size" "$USR_SIZE")
[ -n "$USR_DIR" ] && args+=("--usr-dir" "$USR_DIR")
[ -n "$USR_AUTOEXTEND" ] && args+=("--usr-autoextend" "$USR_AUTOEXTEND")
[ -n "$USR_NEXTSIZE" ] && args+=("--usr-nextsize" "$USR_NEXTSIZE")
[ -n "$USR_MAXSIZE" ] && args+=("--usr-maxsize" "$USR_MAXSIZE")
[ -n "$SYSSUB_SIZE" ] && args+=("--syssub-size" "$SYSSUB_SIZE")
[ -n "$SYSSUB_DIR" ] && args+=("--syssub-dir" "$SYSSUB_DIR")
[ -n "$SYSSUB_AUTOEXTEND" ] && args+=("--syssub-autoextend" "$SYSSUB_AUTOEXTEND")
[ -n "$SYSSUB_NEXTSIZE" ] && args+=("--syssub-nextsize" "$SYSSUB_NEXTSIZE")
[ -n "$SYSSUB_MAXSIZE" ] && args+=("--syssub-maxsize" "$SYSSUB_MAXSIZE")
[ -n "$BACKUP_CTRLFILE" ] && args+=("--backup-ctrlfile" "$BACKUP_CTRLFILE")
[ -n "$SYSTEM_SCRIPT" ] && args+=("--system-script" "$SYSTEM_SCRIPT")


# creating the database
echo "Creating the database"
$TB_HOME/bin/tb_create_db.sh "${args[@]}"
echo "70% complete"

# Setting Archive log mode
if [ -n "$ARCHIVE_LOG_MODE" ] && [ "$ARCHIVE_LOG_MODE" == "Y" -o "$ARCHIVE_LOG_MODE" == "y" ]; then
  echo "Setting Archive log mode"
  tbdown
  tbboot mount
  tbsql sys/"$TB_ROOT_PASSWORD" <<EOF
ALTER DATABASE ARCHIVELOG;
EOF
  tbdown
  tbboot
fi
echo "90% complete"


# Setting up the database user
echo "Setting up the database user"

if { [ -n "${TB_USER:-}" ] && [ -z "${TB_PASSWORD:-}" ]; } || \
   { [ -z "${TB_USER:-}" ] && [ -n "${TB_PASSWORD:-}" ]; }; then
  echo "Cannot create database user: both TB_USER and TB_PASSWORD must be provided."
fi

if [ -n "${TB_USER:-}" ] && [ -n "${TB_PASSWORD:-}" ]; then
  tbsql "sys/${TB_ROOT_PASSWORD}" <<EOF
create user ${TB_USER} identified by '${TB_PASSWORD}';
grant dba to ${TB_USER};
EOF
fi

echo "100% complete"
echo "Tibero installation and database creation completed successfully."
```

#### 4. 도커 이미지 빌드

아래 커맨드를 통해 도커 이미지를 빌드합니다. 원하는 이미지명과 태그로 수정해서 사용합니다.

```bash
docker build -t <이미지명>:<태그> .
```

{% hint style="info" %}
**참고**

커맨드의  마지막 '.' 은 현재 경로에 Dockerfile이 존재함을 의미합니다.
{% endhint %}

{% hint style="warning" %}
**주의**

Tibero 바이너리 압축파일명은 반드시 "tibero.tar.gz" 로 지정 합니다.&#x20;
{% endhint %}

이때 도커 이미지 빌드를 위해 필요한 파일은 아래와 같습니다.

```
.
├── Dockerfile
├── tibero.tar.gz
└── scripts
    ├── entrypoint.sh
    ├── install_dependency.sh
    └── install_tibero.sh
```

###

***

## 2. Tibero  컨테이너 생성

아래 Tibero 공식 도커허브를 참고하여, 빌드한 도커 이미지를 통해 컨테이너를 생성합니다.

> **Tibero 공식 도커 허브**
>
> <https://hub.docker.com/r/tiberoofficial/tibero>

###


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.tibero.com/technical-guides/topics/installation/docker-image.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.