Get Started with
OceanBase Community Edition

OceanBase is a native distributed relational database that is compatible with MySQL and supports enterprise-level features such as financial-grade high availability, transparent horizontal scaling, distributed transactions, and multi-tenancy. For more information, see Overview.

This topic describes how to deploy OceanBase Database, connect to it, and run SQL statements to verify the deployment. Choose a deployment method based on your operating system to get started. When you finish, you will have a running OceanBase Database instance that you can access with obclient to run SQL statements.

Prerequisites

Before you install OceanBase Database, make sure that your software and hardware environments meet the following requirements:

Choose a deployment method

The following methods quickly set up a single-machine OceanBase Database environment. The resulting instance provides the basic functionality you need to get familiar with OceanBase Database, but it does not support distributed features such as high availability and horizontal scaling, so it is not recommended for long-term use.

Choose the method that suits your operating system and usage scenario:

In the command-line examples below, a leading $ indicates executing the command as a regular user, while a leading # indicates executing the command as the root user (including the root environment within a Docker container). The prompt itself does not need to be entered.

Method 1: Use the All-in-One package (recommended)

The All-in-One package deploys the following components in a single step:

• obd: OceanBase Deployer. For more information, see obd.
• ODP: OceanBase Database Proxy (also known as OBProxy). For more information, see OceanBase Database Proxy (ODP).
• obshell: an OceanBase Database management tool that provides the obshell Dashboard for visual management. The access address and login password are included in the deployment output.
• OBAgent: a monitoring and data collection framework that supports both push and pull modes.
• Grafana: Data visualization tool. For more information, see Grafana official website.
• Prometheus: Monitoring system and time series database. For more information, see Prometheus official website.

Run the following command to download and install OceanBase All-in-One. It downloads and installs the latest version of the OceanBase All-in-One package.

$ bash -c "$(curl -s https://obbusiness-private.oss-cn-shanghai.aliyuncs.com/download-center/opensource/oceanbase-all-in-one/installer.sh)"
$ source ~/.oceanbase-all-in-one/bin/env.sh

The source command loads the environment variables. After it runs, you can use commands such as obd and obclient directly in the current terminal.

Run the following command to deploy and start a single-node OceanBase Database with minimum specifications (using the current account):

$ obd demo

The command displays the download and startup progress of each component. The time required depends on your network environment, so please be patient. After successful deployment, the deployment information and connection method for each component will be output at the end of the command. Key outputs are as follows (version numbers, passwords, etc., should match your actual environment):

Wait for observer init ok
+---------------------------------------------+
|                 oceanbase-ce                |
+-----------+---------+------+-------+--------+
| ip        | version | port | zone  | status |
+-----------+---------+------+-------+--------+
| 127.0.0.1 | 5.0.1.0 | 2881 | zone1 | ACTIVE |
+-----------+---------+------+-------+--------+
obclient -h127.0.0.1 -P2881 -uroot@sys -p'qKxxxxxxxxxxxxxxxxxx' -Doceanbase -A
...
demo running

When demo running appears in the output and the status of the oceanbase-ce component is ACTIVE, the deployment is successful. The line starting with obclient is the database connection command. The password following -p is a randomly generated login password for the root user of the sys tenant. Please keep it secure.

Connect to the database

obclient is the command-line client for OceanBase Database, and it is used in much the same way as the MySQL client. After obd demo or obd perf runs successfully, it prints the connection commands for the deployed components. Copy a connection command from the output and run it to log in to the sys tenant of the cluster as the root user. The default connection command is as follows:

$ obclient -h127.0.0.1 -uroot@sys -P2881 -p -A oceanbase

The parameters in the connection command are described as follows:

The password for the root user of the sys tenant is randomly generated when deployment completes. It appears after the -p parameter in the obclient connection command in the deployment output. If you forget the password, run the following command and read it from the connection command that is printed:

$ obd cluster display demo

After a successful connection, the response information is as follows (the connection ID, version number, and other details are subject to the actual environment):

Enter password:
Welcome to the OceanBase.  Commands end with ; or \g.
Your OceanBase connection id is 3221225985
Server version: OceanBase 5.0.1.0 (r100000042026072711-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx) (Built Jul 27 2026 11:00:00)

Copyright (c) 2000, 2018, OceanBase and/or its affiliates. All rights reserved.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

obclient [oceanbase]>

After logging in, you can run SQL statements to try out basic database operations.

Offline installation (Optional)

$ tar -xzf oceanbase-all-in-one-*.tar.gz
$ cd oceanbase-all-in-one/bin/
$ ./install.sh
$ source ~/.oceanbase-all-in-one/bin/env.sh

After offline installation is complete, use the obd demo or obd perf command to deploy it. For detailed steps, refer to the "Offline installation" section in Deploy OceanBase Database in production using the command line.

Subsequent management: Start and stop

After deployment, you can manage OceanBase Database and its components using obd cluster commands (such as viewing the cluster status, starting, stopping, and destroying the cluster). The fixed deployment name for the obd demo command is demo. For detailed command descriptions, see the obd documentation Cluster commands. To clean up a deployed cluster, refer to Clean up an old cluster.

Method 2: Use the RPM package

Deploy using systemctl commands

$ sudo bash -c "$(curl -s https://obbusiness-private.oss-cn-shanghai.aliyuncs.com/download-center/opensource/service/installer.sh)"

This command is for a quick experience. It downloads the latest LTS version of the RPM package online and installs it directly as the root user. You can then manage OceanBase Database with systemctl commands. For detailed configuration and offline installation steps, see Deploy OceanBase Database using systemd.

After the installation script finishes executing, OceanBase Database registers as a systemd service and starts automatically. Service startup takes some time. You can run sudo systemctl status oceanbase to check the service status. If it shows active (running), the startup was successful. If the script indicates a service startup failure at the end, you can run sudo journalctl -u oceanbase to view detailed logs. If errors related to OB_NO_SUCH_FILE_OR_DIRECTORY appear in the logs, it is usually due to the absence of the default data directory (/var/lib/oceanbase). You can run the following commands to create the data directory, change its owner, and then restart:

$ sudo mkdir -p /var/lib/oceanbase/data /var/lib/oceanbase/redo
$ sudo chown -R admin:admin /var/lib/oceanbase
$ sudo systemctl start oceanbase

Connect to the database

If obclient (the OceanBase Database command-line client, which is used in the same way as the MySQL client) is not installed on your machine, you can configure a yum repository and then run sudo yum install obclient to install it. Alternatively, go to the OceanBase Download Center to download the installation package for the corresponding version.

Upon successful command execution, the connection command for OceanBase Database is printed. Copy the connection string from the output and run it to log in to the sys tenant of the cluster as the root user. The default connection command is as follows:

$ obclient -h127.0.0.1 -uroot@sys -P2881 -p -A oceanbase

The default password for the root user in the sys tenant is empty. When prompted to enter a password, just press Enter to log in. For parameter descriptions of the connection command and an example of the return information after a successful connection, see "Connect to the database" in Method 1.

Subsequent management: Start and stop

OceanBase Database installed via the preceding installation script registers as a systemd service and can be managed using systemctl commands. Currently, support includes start, stop, and status operations. For detailed operations and explanations of each status, see the "Manage OceanBase Database" section in Deploy OceanBase Database using systemd.

Manual deployment (optional): customize the directory and startup parameters

Step 1: Install the RPM package

Download the required version of the OceanBase Database RPM package from the OceanBase Download Center and upload it to the target machine. Execute the following command in the directory where the RPM package is located to install it (replace the file name with the actual downloaded package version):

$ sudo rpm -ivh oceanbase-5.0.1.0-100000042026072711.el7.x86_64.rpm

After installation, the installation directory for OceanBase Database is /home/admin/oceanbase, and the executable file is /home/admin/oceanbase/bin/observer.

Step 2: Initialize the data directory

Create the data directory, log directory, and cluster data directory in sequence:

$ sudo mkdir -p /data/1/ob_test/{etc3,sstable,slog}
$ sudo mkdir -p /data/log1/ob_test/{clog,etc2}
$ sudo mkdir -p /home/admin/oceanbase/store/ob_test

ob_test is a directory named after the cluster name. You can customize the cluster name with the -d parameter when you start the observer process.

Switch to the root user and change the owner and group of the preceding directories to admin:

$ sudo -i

# cd /data/1/
# chown -R admin:admin ob_test

# cd /data/log1/
# chown -R admin:admin ob_test

# cd /home/admin/oceanbase/
# chown -R admin:admin store

Stay as the root user and create soft links for each directory:

# for t in {etc3,sstable,slog}; do ln -s /data/1/ob_test/$t /home/admin/oceanbase/store/ob_test/$t; done
# for t in {clog,etc2}; do ln -s /data/log1/ob_test/$t /home/admin/oceanbase/store/ob_test/$t; done

Execute the following command to check the directory structure:

# tree /home/admin/oceanbase/store/

A sample return result is shown below. All five subdirectories are soft-linked to the corresponding data and log directories, indicating that directory initialization is complete:

/home/admin/oceanbase/store/
└── ob_test
    ├── clog -> /data/log1/ob_test/clog
    ├── etc2 -> /data/log1/ob_test/etc2
    ├── etc3 -> /data/1/ob_test/etc3
    ├── slog -> /data/1/ob_test/slog
    └── sstable -> /data/1/ob_test/sstable

6 directories, 0 files

Step 3: Start the observer process

Common startup parameters for the observer process are as follows:

Execute the ifconfig command to confirm the network interface card name and business IP:

# ifconfig

The return result is as follows:

eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 10.10.10.1  netmask 255.255.252.0  broadcast 10.10.155.255
        ...
lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        ...

If the server has multiple network interfaces, set the -I parameter to the IP address of the interface that carries your business IP. Do not use the loopback address (127.0.0.1) or a container NIC such as docker0.

Switch to the admin user and start the observer process. The root user can switch to admin without a password. The following example uses an 8C32G specification: make sure that the server has at least 32 GB of memory, and that the data disk and log disk have at least 100 GB and 50 GB of free space, respectively. The minimum requirements listed in Prerequisites apply only to quick deployments such as obd demo and Docker MINI. Replace the IP addresses in -I and -r with the business IP that you identified in the previous step:

# su - admin

$ cd /home/admin/oceanbase && /home/admin/oceanbase/bin/observer -I 10.10.10.1 -P 2882 -p 2881 -z zone1 -d /home/admin/oceanbase/store/ob_test -r 10.10.10.1:2882:2881 -c 10001 -n ob_test -o "cpu_count=8,memory_limit=32G,system_memory=8G,datafile_size=100G,log_disk_size=50G,__min_full_resource_pool_memory=1073741824,resource_hard_limit=100,config_additional_dir=/data/1/ob_test/etc3;/data/log1/ob_test/etc2"

After the command executes, the return information is as follows:

local_ip: 10.10.10.1
rpc port: 2882
mysql port: 2881
zone: zone1
data_dir: /home/admin/oceanbase/store/ob_test
rs list: 10.10.10.1:2882:2881
cluster id: 10001
appname: ob_test

After the command executes, the observer process has started in the background.

The key startup parameters in the -o parameter are described as follows:

Run the following command to confirm that the observer process has started normally:

$ ps -ef | grep observer

The return result is as follows (the specific process ID depends on the actual environment):

admin     31578      1 28 17:11 ?        00:00:47 /home/admin/oceanbase/bin/observer -I 10.10.10.1 -P 2882 -p 2881 -z zone1 -d /home/admin/oceanbase/store/ob_test -r 10.10.10.1:2882:2881 -c 10001 -n ob_test -o cpu_count=8,memory_limit=32G,...

Confirm that the process runs as the admin user and that the command-line parameters match those used at startup.

Run the following command to confirm that the version matches the installed RPM package version:

$ /home/admin/oceanbase/bin/observer -V

The version number in the return result (for example, 5.0.1.0) is the current version of observer.

Step 4: Bootstrap the cluster

After the process starts, wait about one minute for initialization to complete, and then use obclient to connect to this node (if obclient is not installed, see the "Connect to the database" section in Method 2 for installation instructions; the root user of the sys tenant has an empty default password, so just press Enter when prompted). Connecting too early may cause an error, so wait a moment and try again:

$ obclient -h127.0.0.1 -uroot -P2881 -p

A sample return result is as follows (connection ID, version number, and other information are subject to the actual environment):

Enter password:
Welcome to the OceanBase.  Commands end with ; or \g.
Your OceanBase connection id is 3221225985
Server version: OceanBase 5.0.1.0 (r100000042026072711-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx) (Built Jul 27 2026 11:00:00)

Copyright (c) 2000, 2018, OceanBase and/or its affiliates. All rights reserved.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

obclient [(none)]>

Execute the following statement to initialize the cluster (for single-node deployment, SERVER specifies the local business IP and RPC port):

obclient [(none)]> ALTER SYSTEM BOOTSTRAP ZONE 'zone1' SERVER '10.10.10.1:2882';

The return result should be Query OK, 0 rows affected (the actual time consumed depends on machine performance).

Execute the following statement to verify that the cluster has been successfully initialized:

obclient [(none)]> SHOW DATABASES;

A sample return result is shown below; seeing the oceanbase database indicates successful cluster initialization:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| LBACSYS            |
| mysql              |
| oceanbase          |
| ORAAUDITOR         |
| SYS                |
| sys_external_tbs   |
| test               |
+--------------------+
8 rows in set

Method 3: Quick experience using Docker

For quick experience scenarios on operating systems that are not natively supported (such as macOS and Windows), it is recommended to deploy using Docker images. For detailed steps, see Deploy the OceanBase Database container environment.

Start the OceanBase container

If the OceanBase database image does not exist locally, the latest image will be automatically pulled from Docker Hub when you run the startup command. You can also run the following command in advance to pull the image:

$ sudo docker pull oceanbase/oceanbase-ce

Run the following command to start an OceanBase database instance:

$ sudo docker run -p 2881:2881 -p 2886:2886 -v $PWD/ob:/root/ob -v $PWD/obd/cluster:/root/.obd/cluster --name obstandalone -e MODE=MINI -d oceanbase/oceanbase-ce

Upon successful execution, the command returns a container ID (a 64-bit hexadecimal string). At this point, the container has started in the background, but OceanBase Database is still initializing.

• -p: Maps container ports to host ports. In the example, ports 2881 and 2886 in the container are mapped to the same ports on the host.
• -v: Shares files or directories between the container and the host to achieve data persistence. By default, the system deploys OceanBase Database in the container's /root/ob directory and saves its configuration in /root/.obd/cluster.
• --name: Sets the Docker container name.
• -e: Sets environment variables. Here, MODE sets the startup mode, and OB_TENANT_PASSWORD sets the password for the root@test user.

Startup takes about 2 to 5 minutes. Run the following command. If it returns boot success!, the database has started successfully:

$ sudo docker logs obstandalone | tail -1

A sample return result is as follows:

boot success!

Connect to the database

The oceanbase-ce image includes obd and obclient. You can either enter the container and connect to the instance with obclient, or connect from the host with a local obclient or MySQL client.

Connect after entering the container (after running the sudo docker exec command, the command prompt changes to root@<container ID>:/#, indicating you are inside the container environment):

$ sudo docker exec -it obstandalone bash
# obclient -h127.0.0.1 -uroot@sys -P2881 -p -A oceanbase

Or connect from the host with a local client (the host must have obclient or a MySQL client installed):

$ obclient -h127.0.0.1 -uroot@sys -P2881 -p -A oceanbase

Subsequent management: Manage within the container

In Docker mode, OceanBase Database starts and stops with the container. Run sudo docker stop obstandalone to stop the container, which also stops OceanBase Database, and sudo docker start obstandalone to restart it. Because the deployment data is mounted to a host directory through the -v option, no data is lost when the container stops or is deleted. After you enter the container, you can also use obd commands to view and manage the cluster. For detailed command descriptions, see the obd documentation Cluster commands.

Connection verification

After OceanBase Database starts successfully, run the following SQL statements in the session that connects to the database to confirm that the cluster is running properly.

1. Check the status of cluster nodes. The return result includes information such as the node IP address, port, zone, and status:

   obclient [oceanbase]> SELECT * FROM oceanbase.DBA_OB_SERVERS\G
   

   The following example shows the return result (using the single-node cluster ob_test as an example; the time, version number, and other details depend on your environment):

   *************************** 1. row ***************************
                SVR_IP: 10.10.10.1
              SVR_PORT: 2882
                    ID: 1
                  ZONE: zone1
              SQL_PORT: 2881
       WITH_ROOTSERVER: YES
                STATUS: ACTIVE
   START_SERVICE_TIME: 2026-10-09 10:00:00.000000
            STOP_TIME: NULL
   BLOCK_MIGRATE_IN_TIME: NULL
            CREATE_TIME: 2026-10-09 10:00:00.000000
            MODIFY_TIME: 2026-10-09 10:00:00.000000
           BUILD_VERSION: 5.0.1.0_100000042026072711-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(Jul 27 2026 11:00:00)
       LAST_OFFLINE_TIME: NULL
   

   When the STATUS column is ACTIVE, it indicates that the OBServer node is running normally. For detailed column descriptions, see DBA_OB_SERVERS.

2. View tenant information:

   obclient [oceanbase]> SELECT * FROM oceanbase.DBA_OB_TENANTS\G
   

   The following example shows the return result. If you have created a business tenant, such as mysql001, the records of that tenant and its corresponding Meta tenant, such as META$1002, are also returned:

   *************************** 1. row ***************************
                    TENANT_ID: 1
                  TENANT_NAME: sys
                  TENANT_TYPE: SYS
                  CREATE_TIME: 2026-10-09 10:00:00.000000
                  MODIFY_TIME: 2026-10-09 10:00:00.000000
                 PRIMARY_ZONE: RANDOM
                     LOCALITY: FULL{1}@zone1
              TABLEGROUP_NAME: NULL
            PREVIOUS_LOCALITY: NULL
           COMPATIBILITY_MODE: MYSQL
                       STATUS: NORMAL
                IN_RECYCLEBIN: NO
                       LOCKED: NO
                  TENANT_ROLE: PRIMARY
            SWITCHOVER_STATUS: NORMAL
             SWITCHOVER_EPOCH: 0
                     SYNC_SCN: NULL
               REPLAYABLE_SCN: NULL
                 READABLE_SCN: NULL
           RECOVERY_UNTIL_SCN: NULL
                   LOG_MODE: NOARCHIVELOG
   ARBITRATION_SERVICE_STATUS: DISABLED
                   UNIT_NUM: 1
           ZONE_UNIT_NUM_LIST: zone1:1
                   COMPATIBLE: 5.0.1.0
                    MAX_LS_ID: 1
            RESTORE_DATA_MODE: NORMAL
            FLASHBACK_LOG_SCN: NULL
                    COMMENT: system tenant
            PROTECTION_MODE: NULL
           PROTECTION_LEVEL: NULL
          DEFAULT_TABLESPACE: NULL
   

   When the STATUS column for the sys tenant is NORMAL, it indicates that the tenant is running normally. For detailed column descriptions, see DBA_OB_TENANTS.

What to do next

After completing the deployment experience in this topic, you can continue with the following exploration:

1. Connect and perform SQL operations: Connect to the database and run basic SQL statements to experience the MySQL compatibility of OceanBase Database.
2. Create a business tenant: Create an independent tenant to experience the multi-tenant isolation capability of OceanBase Database. For more information, see Experience multi-tenancy and resource isolation.
3. Experience high-concurrency OLTP: Experience the transaction processing capability of OceanBase Database through TPC-C stress testing. For more information, see Experience high-concurrency OLTP scenarios.
4. Experience HTAP mixed workloads: Experience the hybrid row-column storage and parallel analysis capabilities of OceanBase Database through TPC-H testing. For more information, see Experience HTAP mixed workloads.

References

• For more information about how to deploy OceanBase Database Community Edition and its application scenarios, see Overview.
• For more information about how to deploy OceanBase Database Enterprise Edition, see Overview.
• For more information about how to clean up an old cluster, see Clean up an old cluster.