### Mount File-Only Example with Podman

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/examples/README.md

Demonstrates mounting a setup script (setup-columnar-store.sh) into an Oracle XE container using Podman. It configures the In-Memory Columnar Store.

```sh
podman run -e ORACLE_PASSWORD=test -p 1521:1521 --mount type=bind,src=./setup-columnar-store.sh,dst=/container-entrypoint-initdb.d/setup-columnar-store.sh,relabel=shared gvenzl/oracle-xe:21.3.0-slim
```

--------------------------------

### Start Basic Oracle XE Container (Bash)

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Starts an ephemeral Oracle XE container with port mapping and a custom password. Includes commands to connect to the database using SQL*Plus and provides example connection strings for applications.

```bash
# Start Oracle XE 21c with custom password
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=MySecurePass123 gvenzl/oracle-xe

# Connect to the database
sqlplus system/MySecurePass123@//localhost:1521/XE

# Example connection string for applications
# JDBC: jdbc:oracle:thin:@localhost:1521:XE
# SQL*Plus: sqlplus system/MySecurePass123@//localhost:1521/XE
```

--------------------------------

### Configure In-Memory Columnar Store for Oracle XE

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/examples/README.md

Configures the database with the In-Memory Columnar Store. This setup is intended to be performed during container initialization by mounting the script.

```bash
#!/bin/bash
# setup-columnar-store.sh
# Mount this script into the container at /container-entrypoint-initdb.d/
```

--------------------------------

### Verify Sample Data Installation

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

After the Oracle XE container has initialized and executed the scripts, this SQL command connects to the database as the 'test' user and queries the 'countries' table to verify the installation of sample data, specifically checking for an entry with the name 'Austria'.

```sql
sqlplus test/test@//localhost/XEPDB1

SQL> select * from countries where name = 'Austria';

```

--------------------------------

### Download and Install Sample Data using Shell

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

This shell script downloads the 'install.sql' script, executes it using 'sqlplus' with the 'test' user credentials, and then removes the downloaded script. It's designed to be run after the user has been created.

```shell
curl -LJO https://raw.githubusercontent.com/gvenzl/sample-data/master/countries-cities-currencies/install.sql
sqlplus -s test/test@//localhost/XEPDB1 @install.sql

rm install.sql

```

--------------------------------

### Run Startup Scripts in Oracle XE Docker

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Illustrates how to create and execute scripts that run every time an Oracle XE Docker container starts. These scripts are placed in a volume mounted to `/container-entrypoint-startdb.d` and are useful for recurring configurations.

```bash
# Create startup scripts directory
mkdir -p /home/user/startup_scripts

# Create script to enable debugging (startup_debug.sql)
cat > /home/user/startup_scripts/startup_debug.sql << 'EOF'
ALTER SESSION SET CONTAINER=XEPDB1;
ALTER SYSTEM SET SQL_TRACE=TRUE;
EOF

# Run container with startup scripts
docker run -d \
  --name oracle-with-startup \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -v /home/user/startup_scripts:/container-entrypoint-startdb.d \
  -v oracle-volume:/opt/oracle/oradata \
  gvenzl/oracle-xe

# Scripts execute after database starts (including restarts)
docker restart oracle-with-startup
# Startup scripts execute again after restart
```

--------------------------------

### Create Oracle XE Container with Docker

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/examples/README.md

Creates an Oracle XE container using Docker. This script requires host and port information, along with a container name as parameters.

```bash
#!/bin/bash
# dkr-create-oracle-xe-server <hostXePort> <containerName>
# Example: ./dkr-create-oracle-xe-server 1521 my-oracle-xe
```

--------------------------------

### Run Oracle XE on Apple M Chips using Colima

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This explains how to run Oracle XE on Apple Silicon Macs by using x86_64 emulation via Colima, as Oracle XE does not natively support ARM. It includes installing Colima, starting it with the correct architecture, and verifying the system's architecture before running the Docker container.

```bash
# Install Colima
brew install colima

# Start Colima with x86_64 architecture and sufficient memory
colima start --arch x86_64 --memory 4

# Verify architecture
docker info | grep Architecture

# Run Oracle XE as usual
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe

# Note: For ARM support, use gvenzl/oracle-free (23ai+)
```

--------------------------------

### Copy TDE Setup Script to Oracle XE Container

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This snippet demonstrates how to copy a TDE (Transparent Data Encryption) setup script into the Oracle XE container using Docker. It mounts the script to `/container-entrypoint-initdb.d/` which allows it to be executed during container initialization. This is useful for setting up encrypted wallets in Oracle XE.

```bash
docker run -d \
  --name oracle-tde \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -v /path/to/examples/setup-tde.sh:/container-entrypoint-initdb.d/setup-tde.sh \
  -v oracle-tde-volume:/opt/oracle/oradata \
  gvenzl/oracle-xe
```

```bash
podman run -d \
  -e ORACLE_PASSWORD=AdminPass123 \
  -p 1521:1521 \
  --mount type=bind,src=./setup-tde.sh,dst=/container-entrypoint-initdb.d/setup-tde.sh,relabel=shared \
  gvenzl/oracle-xe:21
```

--------------------------------

### Configure Transparent Data Encryption (TDE) for Oracle XE

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/examples/README.md

Configures the database for Transparent Data Encryption in United Mode. The script should be mounted under `/container-entrypoint-initdb.d` within the container.

```bash
#!/bin/bash
# setup-tde.sh
# Mount this script into the container at /container-entrypoint-initdb.d/
```

--------------------------------

### Connect to Oracle XE PDBs using SQL*Plus

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Provides examples of connecting to both the default PDB (XEPDB1) and a custom PDB (MYPDB) using SQL*Plus, including connecting as a specific application user.

```bash
# Connect to default PDB (XEPDB1)
sqlplus system/AdminPass123@//localhost:1521/XEPDB1

# Connect to custom PDB (MYPDB)
sqlplus system/AdminPass123@//localhost:1521/MYPDB

# Connect as app user in custom PDB
sqlplus myapp/AppPass123@//localhost:1521/MYPDB
```

--------------------------------

### Colima Configuration for Apple M Chips

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

Steps to configure colima to run x86_64 Oracle XE images on Apple M chips. This involves installing colima, starting it with a specific architecture and memory allocation, and then running the Docker container as usual.

```shell
# Install colima (refer to colima documentation for installation instructions)
# https://github.com/abiosoft/colima#installation

# Start colima with x86_64 architecture and 4GB memory
colima start --arch x86_64 --memory 4

# Start Oracle XE container as usual (example)
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=<your password> gvenzl/oracle-xe
```

--------------------------------

### Integrate Oracle XE in GitHub Actions

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Provides a GitHub Actions workflow example that uses the Oracle XE Docker image as a service container for running automated tests. It configures environment variables, ports, and health checks for the service.

```yaml
name: Database Tests

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest

    services:
      oracle:
        image: gvenzl/oracle-xe:latest
        env:
          ORACLE_PASSWORD: TestPass123
          APP_USER: testuser
          APP_USER_PASSWORD: TestUserPass456
        ports:
          - 1521:1521
        options: >-
          --health-cmd healthcheck.sh
          --health-interval 10s
          --health-timeout 5s
          --health-retries 10

    steps:
      - name: Check out code
        uses: actions/checkout@v3

      - name: Wait for database
        run: |
          echo "Database is ready"

      - name: Run tests
        env:
          DB_HOST: localhost
          DB_PORT: ${{ job.services.oracle.ports[1521] }}
          DB_SERVICE: XEPDB1
          DB_USER: testuser
          DB_PASSWORD: TestUserPass456
        run: |
          # Example with SQLcl
          echo "SELECT 'Connection successful!' FROM dual;" | \
          sql testuser/TestUserPass456@localhost:1521/XEPDB1

          # Run your test suite
          ./gradlew test
```

--------------------------------

### Use Oracle XE Container Secrets (Bash)

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Demonstrates how to securely pass sensitive information like passwords to an Oracle XE container using Docker secrets instead of environment variables. Shows examples for single and multiple secrets.

```bash
# Create secret file
echo "MySecretPassword123" > /tmp/oracle-secret.txt

# Run with Docker secrets
docker run -d \
  --name oracle-with-secret \
  -p 1521:1521 \
  -e ORACLE_PASSWORD_FILE=/run/secrets/oracle-passwd \
  -v /tmp/oracle-secret.txt:/run/secrets/oracle-passwd:ro \
  gvenzl/oracle-xe

# Using multiple secrets
echo "AppPassword456" > /tmp/app-user-secret.txt

docker run -d \
  --name oracle-multi-secret \
  -p 1521:1521 \
  -e ORACLE_PASSWORD_FILE=/run/secrets/oracle-passwd \
  -e APP_USER=myapp \
  -e APP_USER_PASSWORD_FILE=/run/secrets/app-passwd \
  -v /tmp/oracle-secret.txt:/run/secrets/oracle-passwd:ro \
  -v /tmp/app-user-secret.txt:/run/secrets/app-passwd:ro \
  gvenzl/oracle-xe
```

--------------------------------

### Run Oracle XE Docker Container

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

Starts a new Oracle XE database container. By default, data is removed when the container is removed, but it is preserved across container restarts. Uses port 1521 and requires setting an ORACLE_PASSWORD environment variable.

```shell
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=<your password> gvenzl/oracle-xe
```

--------------------------------

### Configure In-Memory Columnar Store for Oracle XE

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This section demonstrates how to configure Oracle Database In-Memory for analytics workloads. It includes running a container with a setup script, verifying the `inmemory_size` parameter, and enabling specific tables for In-Memory storage.

```bash
# Run container with In-Memory configuration
docker run -d \
  --name oracle-inmemory \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -v /path/to/examples/setup-columnar-store.sh:/container-entrypoint-initdb.d/setup-columnar.sh \
  -v oracle-inmemory-volume:/opt/oracle/oradata \
  gvenzl/oracle-xe
```

```bash
# Verify In-Memory is enabled
docker exec oracle-inmemory sqlplus / as sysdba << EOF
SHOW PARAMETER inmemory_size;
exit;
EOF
```

```bash
# Enable table for In-Memory
docker exec oracle-inmemory sqlplus myapp/AppPass@//localhost/XEPDB1 << EOF
ALTER TABLE my_analytics_table INMEMORY;
exit;
EOF
```

--------------------------------

### GitHub Actions Service Configuration for Oracle XE

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

This configuration demonstrates how to set up the Oracle XE Docker image as a service container within a GitHub Actions workflow. It specifies environment variables for password generation and application user setup, port forwarding, and health check options for robust startup.

```yaml
services:

  # Oracle service (label used to access the service container)
  oracle:

    # Docker Hub image (feel free to change the tag "latest" to any other available one)
    image: gvenzl/oracle-xe:latest

    # Provide passwords and other environment variables to container
    env:
      ORACLE_RANDOM_PASSWORD: true
      APP_USER: my_user
      APP_USER_PASSWORD: my_password_which_I_really_should_change

    # Forward Oracle port
    ports:
      - 1521:1521

    # Provide healthcheck script options for startup
    options: >-
      --health-cmd healthcheck.sh
      --health-interval 10s
      --health-timeout 5s
      --health-retries 10

```

--------------------------------

### Create Persistent Oracle XE Database Container (Bash)

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Creates and starts an Oracle XE database container with persistent storage using Docker volumes. Supports different versions (21c/18c and 11g R2) with specific volume paths. Includes commands to verify container status and restart.

```bash
# Create and start persistent database (21c/18c)
docker run -d \
  --name oracle-persistent \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=MySecurePass123 \
  -v oracle-volume:/opt/oracle/oradata \
  gvenzl/oracle-xe

# For 11g R2 (different volume path)
docker run -d \
  --name oracle-11g \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=MySecurePass123 \
  -v oracle-volume:/u01/app/oracle/oradata \
  gvenzl/oracle-xe:11

# Verify container is running and healthy
docker ps
docker logs oracle-persistent

# Stop and restart - data persists
docker stop oracle-persistent
docker start oracle-persistent
```

--------------------------------

### Run Persistent Oracle XE 11g R2 Docker Container

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

Starts a new Oracle XE 11g R2 database container with persistent storage. Note that the volume path differs for 11g R2. Uses port 1521 and requires setting an ORACLE_PASSWORD environment variable.

```shell
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=<your password> -v oracle-volume:/u01/app/oracle/oradata gvenzl/oracle-xe:11
```

--------------------------------

### Reset Oracle XE Database Passwords (Bash)

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Provides a command to reset the SYS and SYSTEM user passwords for an existing Oracle XE container. Includes an example using a specific container name and a verification step to test the new password.

```bash
# Reset passwords on running container
docker exec <container-name> resetPassword NewSecurePass456

# Example with specific container name
docker exec oracle-persistent resetPassword MyNewPass789

# Verify new password works
sqlplus system/MyNewPass789@//localhost:1521/XE
```

--------------------------------

### Run Persistent Oracle XE Docker Container

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

Starts a new Oracle XE database container with persistent storage. Data is kept throughout the container's lifecycle using a Docker volume named 'oracle-volume'. Uses port 1521 and requires setting an ORACLE_PASSWORD environment variable.

```shell
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=<your password> -v oracle-volume:/opt/oracle/oradata gvenzl/oracle-xe
```

--------------------------------

### Run Initialization Scripts in Oracle XE Docker

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Demonstrates how to create and execute custom SQL and shell scripts during the initial startup of an Oracle XE Docker container. Scripts are placed in a volume mounted to `/container-entrypoint-initdb.d` and execute in alphabetical order.

```bash
# Create initialization scripts directory
mkdir -p /home/user/init_scripts

# Create user creation script (1_create_user.sql)
cat > /home/user/init_scripts/1_create_user.sql << 'EOF'
ALTER SESSION SET CONTAINER=XEPDB1;

CREATE USER testuser IDENTIFIED BY testpass QUOTA UNLIMITED ON USERS;
GRANT CONNECT, RESOURCE TO testuser;
EOF

# Create data loading script (2_load_data.sh)
cat > /home/user/init_scripts/2_load_data.sh << 'EOF'
#!/bin/bash
curl -LJO https://raw.githubusercontent.com/gvenzl/sample-data/master/countries-cities-currencies/install.sql
sqlplus -s testuser/testpass@//localhost/XEPDB1 @install.sql
rm install.sql
EOF

chmod +x /home/user/init_scripts/2_load_data.sh

# Run container with initialization scripts
docker run -d \
  --name oracle-with-init \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -v /home/user/init_scripts:/container-entrypoint-initdb.d \
  gvenzl/oracle-xe

# Scripts execute in alphabetical order during first startup
# Verify data was loaded
docker exec -it oracle-with-init sqlplus testuser/testpass@//localhost/XEPDB1 << EOF
SELECT COUNT(*) FROM countries;
exit;
EOF
```

--------------------------------

### Select Oracle XE Image Flavors

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This demonstrates how to choose different Oracle XE image flavors based on size and functionality requirements. Options include `slim`, `regular`, `full`, `faststart`, and combinations thereof, allowing optimization for various environments like development or testing.

```bash
# Slim: Smallest size, relational features only (no Text, Spatial, etc.)
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe:21-slim
```

```bash
# Regular: Balanced size and functionality (recommended)
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe:21
```

```bash
# Full: Complete Oracle XE installation with all features
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe:21-full
```

```bash
# Faststart: Pre-expanded database for faster startup (larger image)
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe:21-faststart
```

```bash
# Slim + Faststart: Smallest footprint with fast startup
docker run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe:21-slim-faststart
```

--------------------------------

### Docker Run Command for Oracle XE Initialization

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

This command launches an Oracle XE Docker container, mapping port 1521 and mounting a local directory containing initialization scripts to `/container-entrypoint-initdb.d`. The container automatically executes SQL and shell scripts found in this directory during its first startup.

```shell
docker run --name test \
>          -p 1521:1521 \
>          -e ORACLE_RANDOM_PASSWORD="y" \
>          -v /home/gvenzl/init_scripts:/container-entrypoint-initdb.d \
>      gvenzl/oracle-xe:18.4.0-full

```

--------------------------------

### Create Application Users in Oracle XE (Bash)

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Demonstrates multiple methods for creating dedicated database users for applications. Includes creating users via environment variables during container creation, using the `createAppUser` command within a running container, and for 11g R2 without PDB.

```bash
# Method 1: Using environment variables during container creation
docker run -d \
  --name oracle-with-appuser \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -e APP_USER=myapp \
  -e APP_USER_PASSWORD=AppPass123 \
  gvenzl/oracle-xe

# Connect as application user (18c/21c - connects to XEPDB1)
sqlplus myapp/AppPass123@//localhost:1521/XEPDB1

# Method 2: Using createAppUser command in running container
docker exec oracle-with-appuser createAppUser myapp2 MyApp2Pass XEPDB1

# Method 3: Multiple users with createAppUser
docker exec <container-id> createAppUser analytics AnalyticsPass123 XEPDB1
docker exec <container-id> createAppUser reporting ReportingPass456 XEPDB1

# For 11g R2 (no PDB parameter needed)
docker exec <container-id> createAppUser myapp AppPass123
```

--------------------------------

### Create Oracle User for Sample Data

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

This SQL script creates a new database user named 'TEST' with unlimited quota on the USERS tablespace and grants necessary privileges (CONNECT, RESOURCE). It sets the session to use the XEPDB1 container.

```sql
ALTER SESSION SET CONTAINER=XEPDB1;

CREATE USER TEST IDENTIFIED BY test QUOTA UNLIMITED ON USERS;

GRANT CONNECT, RESOURCE TO TEST;

```

--------------------------------

### Using Oracle XE Container with Podman

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This section details how to use Oracle XE containers with Podman, highlighting its full compatibility with Docker commands and support for rootless containers. It shows standard runs, rootless configurations with volume permissions, and mounting single files with SELinux labels.

```bash
# Run with Podman (identical to Docker)
podman run -d -p 1521:1521 -e ORACLE_PASSWORD=Pass123 gvenzl/oracle-xe
```

```bash
# Rootless with proper volume permissions
podman run -d \
  --name oracle-rootless \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=Pass123 \
  -v oracle-volume:/opt/oracle/oradata:Z \
  gvenzl/oracle-xe
```

```bash
# Mount single file with SELinux label
podman run -d \
  -e ORACLE_PASSWORD=Pass123 \
  -p 1521:1521 \
  --mount type=bind,src=./init.sql,dst=/container-entrypoint-initdb.d/init.sql,relabel=shared \
  gvenzl/oracle-xe
```

--------------------------------

### Create Oracle Database Application User

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

The 'createAppUser' command facilitates the creation of new Oracle Database users with standard privileges. It accepts the desired username, password, and an optional target PDB. This command is useful for managing multiple users or for programmatic user creation within initialization scripts.

```shell
Usage:
  createAppUser APP_USER APP_USER_PASSWORD [TARGET_PDB]

  APP_USER:          the user name of the new user
  APP_USER_PASSWORD: the password for that user
  TARGET_PDB:        the target pluggable database the user should be created in, default XEPDB1 (ignored for 11g R2)
```

```shell
docker exec <container name|id> createAppUser <your app user> <your app user password> [<your target PDB>]
```

--------------------------------

### Create Oracle XE Container with Custom PDB

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This snippet demonstrates how to run an Oracle XE Docker container and create a custom Pluggable Database (PDB) with specified application user credentials and data persistence using Docker volumes.

```bash
docker run -d \
  --name oracle-custom-pdb \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -e ORACLE_DATABASE=MYPDB \
  -e APP_USER=myapp \
  -e APP_USER_PASSWORD=AppPass123 \
  -v oracle-volume:/opt/oracle/oradata \
  gvenzl/oracle-xe
```

--------------------------------

### Use Random Passwords for Oracle XE Container (Bash)

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Shows how to configure an Oracle XE container to automatically generate random passwords for enhanced security in development environments. Includes instructions on how to retrieve the generated password from the container logs.

```bash
# Start container with random password
docker run -d \
  --name oracle-random \
  -p 1521:1521 \
  -e ORACLE_RANDOM_PASSWORD=yes \
  gvenzl/oracle-xe

# View the generated password in logs
docker logs oracle-random | grep "ORACLE PASSWORD"

# Example output:
# ORACLE PASSWORD FOR SYS AND SYSTEM: Xk9mP2nQ4rT8
```

--------------------------------

### Load Oracle Passwords from Container Secrets

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

This feature allows sensitive information, such as passwords, to be loaded from files within the container, typically managed by containerization secret mechanisms. By appending '_FILE' to specific environment variables, the initialization script reads the password from the specified file path, enhancing security by avoiding direct password exposure in environment variables.

```shell
docker run --name some-oracle -e ORACLE_PASSWORD_FILE=/run/secrets/oracle-passwd -d gvenzl/oracle-xe
```

--------------------------------

### Configure Oracle XE Docker Health Checks

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

Shows how to configure Docker health checks for an Oracle XE container to ensure the database is ready before accepting connections. It includes commands to run the container with health checks and to monitor its status.

```bash
# Run with health check configuration
docker run -d \
  --name oracle-healthcheck \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  --health-cmd="healthcheck.sh" \
  --health-interval=30s \
  --health-timeout=10s \
  --health-retries=5 \
  gvenzl/oracle-xe

# Check health status
docker inspect --format='{{.State.Health.Status}}' oracle-healthcheck

# Wait until healthy
while [ "$(docker inspect --format='{{.State.Health.Status}}' oracle-healthcheck)" != "healthy" ]; do
  echo "Waiting for database to be ready..."
  sleep 5
done
echo "Database is ready!"

# Health check for custom PDB
docker exec oracle-healthcheck healthcheck.sh MYPDB
```

--------------------------------

### Verify TDE Configuration in Oracle XE Container

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This code snippet shows how to execute a SQL query inside a running Oracle XE container to verify that TDE (Transparent Data Encryption) is configured. It uses `docker exec` to run `sqlplus` and query the `v$encryption_wallet` view.

```bash
docker exec oracle-tde sqlplus / as sysdba << EOF
SELECT * FROM v$encryption_wallet;
exit;
EOF
```

--------------------------------

### Configure Transparent Data Encryption (TDE) in Oracle XE

Source: https://context7.com/gvenzl/oci-oracle-xe/llms.txt

This section outlines the steps to enable Transparent Data Encryption (TDE) in United Mode for the Oracle XE Docker image, enhancing data security.

```bash
# Command to enable TDE in United Mode
docker run -d \
  --name oracle-tde \
  -p 1521:1521 \
  -e ORACLE_PASSWORD=AdminPass123 \
  -e ENCRYPTION_WALLET_TYPE=UNITED \
  -e ENCRYPTION_PASSWORD=MySecurePassword123 \
  -v tde-wallet:/opt/oracle/secrets/ <<-- THIS IS WRONG, IT SHOULD BE MOUNTED TO THE CORRECT PATH -->>
  gvenzl/oracle-xe
```

--------------------------------

### Reset Oracle XE Container Passwords

Source: https://github.com/gvenzl/oci-oracle-xe/blob/main/README.md

Resets the SYS and SYSTEM database passwords for a running Oracle XE container. Replace `<container name|id>` with the actual container name or ID and `<your password>` with the desired new password.

```shell
docker exec <container name|id> resetPassword <your password>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.