# Oracle AI Database 26ai Free Container Oracle AI Database 26ai Free is the free edition of the industry-leading database. It is available in two container image variants: Full and Lite. Both images use Oracle Linux as their base and include a prebuilt database. | Image | Registry tag | Use it when | | --- | --- | --- | | Full | [`container-registry.oracle.com/database/free:latest`](https://container-registry.oracle.com/ords/ocr/ba/database/free) | You need the complete Oracle AI Database 26ai Free feature set, application development, or advanced database features | | Lite | [`container-registry.oracle.com/database/free:latest-lite`](https://container-registry.oracle.com/ords/ocr/ba/database/free) | You need a smaller, simpler image for CI/CD, demos, or applications that do not require the unsupported features listed in **Lite image limitations** | These container images run with Podman. This guide targets Oracle Linux hosts and Bash-compatible shells. The fastest path is the Quick start. It uses one Podman container, a named volume, and a Podman secret. The remaining sections are optional and can be used as a reference after the database is running. For more information on Oracle AI Database 26ai Free, see the [Oracle AI Database Free page](https://www.oracle.com/database/free/). **Recommended path:** Use the Full image for development unless you specifically need Lite. Supply a password through a Podman secret and persist the database in a named volume. The examples use `latest` for convenience; replace it with a versioned image tag for repeatable environments. **Prefer a native installation?** RPM packages for Linux and the Windows ZIP package are available on the [Oracle AI Database Free downloads page](https://www.oracle.com/database/free/get-started/). The sample scripts used in this guide are available in the [GitHub samples directory](https://github.com/oracle/docker-images/tree/main/OracleDatabase/SingleInstance/samples/client-examples). You can view or download them without cloning the repository. ## Contents - What you will get - Requirements - Choose Full or Lite - Quick start - Connect to the database - Application examples - If you have already run Quick start - Optional Podman Compose - Optional configuration - Persist database files - Run setup and startup scripts - Change database passwords - Manage the container - Lite image limitations - Advanced features and integrations - Troubleshoot ## What you will get When you finish the Quick start, you will have: - An Oracle AI Database 26ai Free database running in the Full image on Oracle Linux with Podman. - A database reachable at `localhost:1521`. - The PDB service `FREEPDB1` for normal application connections. - Database files persisted in the named volume `oracle-free-data`. - The database password stored in the Podman secret `oracle_pwd`. ## Requirements Use an Oracle Linux host with: - [Podman](https://docs.oracle.com/en/operating-systems/oracle-linux/podman/install.html) installed and available in the current user session. - Network access to `container-registry.oracle.com`. No Podman registry secret is needed to pull the Free image. - At least 2 GB of memory available to the container. - At least 13 GB of free space in the container storage location for the Free image. - A host port that can be mapped to listener port `1521`. - `curl` if you want to download the checked-in examples without cloning the repository. If Podman is not installed, run: ```bash sudo dnf install -y podman ``` The examples use the current user's Podman session. Whether rootless Podman is available depends on the host configuration. A named volume is recommended because it avoids host-directory ownership setup. The registry publishes Linux AMD64 and ARM64 tags when those builds are available. Check the current registry tag list before selecting an architecture-specific tag. Check the runtime and available host space before starting: ```bash podman version podman info df -h ``` ## Choose Full or Lite - Choose **Full** for general development, application compatibility, and the complete Free feature set. - Choose **Lite** only when a smaller image or startup footprint is more important than the features listed in **Lite image limitations**. - Use a separate container name and volume for Lite. - Do not switch between Full and Lite on an existing data volume. The Quick start uses the Full image. The examples use `latest` so they can be copied without choosing a tag; pin the image to a versioned tag for repeatable environments. To start Lite instead of Full, use this command instead of the Full Quick start command with a separate container name and volume. If host port `1521` is already in use, change the first port in `--publish` to an available port such as `1522`. ```bash podman run -d \ --name oracle-free-lite \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume oracle-free-lite-data:/opt/oracle/oradata \ container-registry.oracle.com/database/free:latest-lite ``` ## Quick start This section starts the Free container with: - Container name `oracle-free`. - Host port `1521` mapped to the Oracle Listener. - Named volume `oracle-free-data` mounted at `/opt/oracle/oradata`. - Password supplied through the Podman secret `oracle_pwd`. - Default SID `FREE` and PDB service `FREEPDB1`. ### 1. Create a password secret Choose a password that satisfies the [database password policy](https://docs.oracle.com/en/database/oracle/oracle-database/26/dbseg/configuring-authentication.html). The sample script prompts for the password without echoing it and creates the Podman secret: ```bash bash -c "$(curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/secrets/create-password-secret.sh)" ``` ### 2. Start the database Podman pulls the image automatically if it is not already available locally and creates the volume `oracle-free-data` if it does not already exist. Use a separate container name `oracle-free-lite` and volume name `oracle-free-lite-data` for a Lite database. Do not switch between Full and Lite on an existing data volume. Lite image tags include the `-lite` suffix. For example, use `latest` tag for the Full image and `latest-lite` tag for the Lite image. ```bash podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume oracle-free-data:/opt/oracle/oradata \ container-registry.oracle.com/database/free:latest ``` ### 3. Wait for the database readiness Wait until the readiness message appears: ```bash until podman logs oracle-free | grep 'DATABASE IS READY TO USE!'; do sleep 1; done ``` Once the image has been pulled successfully, the database is normally ready in 20 seconds or less. If the readiness message does not appear, inspect the logs: ```bash podman logs --tail=200 oracle-free ``` ### 4. Verify the database is working Run the sample verification script: ```bash curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/sql/verify_database.sql \ | podman exec -i oracle-free sqlplus -s / as sysdba ``` You should see one or more rows beginning with `Oracle AI Database`, followed by the database release and version. For example: ```text BANNER -------------------------------------------------------------------------------- Oracle AI Database 26ai ... ``` If the script returns output beginning with `Oracle AI Database`, the database is running and responding to SQL requests. ## Connect to the database ### Connection values | Connection target | Host | Port | Service | User | Role | | --- | --- | --- | --- | --- | --- | | Default PDB | `localhost` | `1521` | `FREEPDB1` | `PDBADMIN` or an application user | Default | | CDB root | `localhost` | `1521` | `FREE` | `SYS` | `SYSDBA` | For normal application development, connect to the PDB service `FREEPDB1`. Use `PDBADMIN` for an initial test, then create a dedicated application user. Do not use `SYS` or `SYSTEM` for application connections. ### Connection terms - `FREE` is the CDB root and the default SID. - `FREEPDB1` is the default PDB service for application connections. - `SYSDBA` is an administrative role. Do not use it for application connections. ### Create an application user Use the [`create_application_user.sql` sample script](https://github.com/oracle/docker-images/blob/main/OracleDatabase/SingleInstance/samples/client-examples/sql/create_application_user.sql) to create a user in the default PDB. First, download the sample: ```bash curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/sql/create_application_user.sql \ -o create_application_user.sql ``` Replace `ReplaceWithAStrongPassword` in the downloaded file with a strong password. Then run the script from a CDB `SYSDBA` session: ```bash cat create_application_user.sql | podman exec -i oracle-free sqlplus -s / as sysdba ``` Use a separate password for each application user and keep it in your application's secret store. ### SQL*Plus from the host Install [SQL*Plus](https://www.oracle.com/database/technologies/instant-client.html) and enter the database password when SQL*Plus prompts for it: ```bash sqlplus pdbadmin@//localhost:1521/FREEPDB1 ``` To connect to the CDB as SYSDBA: ```bash sqlplus sys@//localhost:1521/FREE as sysdba ``` ### SQL*Plus inside the container ```bash podman exec -it oracle-free sqlplus / as sysdba ``` ## Application examples The examples below connect to the `FREEPDB1` service as `app_user`. Create the user first. ### Python Thin and Thick The [Python example](https://github.com/oracle/docker-images/blob/main/OracleDatabase/SingleInstance/samples/client-examples/python/oracledb_example.py) supports both `python-oracledb` modes. Install `python-oracledb` if it is not already available: ```bash python3 -m pip install oracledb ``` Thin mode is the recommended starting point and does not require Oracle Instant Client: ```bash python3 -c "$(curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/python/oracledb_example.py)" --mode thin ``` Use Thick mode when the application requires Oracle Instant Client: ```bash python3 -c "$(curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/python/oracledb_example.py)" --mode thick --lib-dir /path/to/instantclient ``` Before running the Java or C example, set the shared connection credentials: ```bash export ORACLE_USER=app_user IFS= read -r -s -p 'Database password: ' ORACLE_PASSWORD export ORACLE_PASSWORD ``` ### Java JDBC The [Java JDBC example](https://github.com/oracle/docker-images/blob/main/OracleDatabase/SingleInstance/samples/client-examples/java/JdbcExample.java) requires JDK 17 or later and the latest Oracle Database 26ai [`ojdbc17.jar`](https://www.oracle.com/database/technologies/appdev/jdbc-downloads.html) in the current directory. It uses this default URL: ```text jdbc:oracle:thin:@//localhost:1521/FREEPDB1 ``` Download the source, compile it, and run it: ```bash curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/java/JdbcExample.java \ -o JdbcExample.java javac -cp ojdbc17.jar JdbcExample.java java -cp ".:ojdbc17.jar" JdbcExample ``` ### C / OCI The [C/OCI example](https://github.com/oracle/docker-images/blob/main/OracleDatabase/SingleInstance/samples/client-examples/c/hello_oci.c) requires a C compiler and the Oracle Instant Client Basic and SDK packages. It reads `ORACLE_USER`, `ORACLE_PASSWORD`, and the optional `ORACLE_CONNECT_STRING` environment variables. The default connect string is `localhost:1521/FREEPDB1`. ```bash curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/c/hello_oci.c \ -o hello_oci.c IC_HOME=/path/to/instantclient cc -I"$IC_HOME/sdk/include" hello_oci.c \ -L"$IC_HOME" \ -Wl,-rpath,"$IC_HOME" \ -lclntsh \ -o hello_oci ./hello_oci ``` After running the Java or C example, remove the credentials from the shell environment: ```bash unset ORACLE_USER ORACLE_PASSWORD ``` ## If you have already run Quick start The password secret and named volume are reusable. If the container already exists, do not run the Quick start command again; use the appropriate operation as shown in the following sections. ### Start the existing container ```bash podman start oracle-free until podman logs oracle-free | grep 'DATABASE IS READY TO USE!'; do sleep 1; done ``` ### Recreate the container and keep the data This removes only the container. The database remains in `oracle-free-data`. ```bash podman stop oracle-free podman rm oracle-free podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume oracle-free-data:/opt/oracle/oradata \ container-registry.oracle.com/database/free:latest ``` If `oracle_pwd` already exists, reuse it. Do not create a second secret with the same name. ### Reset the container, secret, and data The final command permanently deletes the database files in the named volume. Use it only when the database can be discarded or has been backed up. ```bash podman stop oracle-free podman rm oracle-free podman secret rm oracle_pwd podman volume rm oracle-free-data ``` ## Optional Podman Compose The basic Podman setup above does not require Compose. Install `podman-compose` only if you want to run SQLcl or an application as a second container. Follow Oracle's [Install Podman Compose instructions](https://docs.oracle.com/en/learn/ol-podman-compose/index.html) and use only the Podman Compose steps in that tutorial. ### SQLcl from a container with Podman Compose The complete [`compose.yaml`](https://github.com/oracle/docker-images/blob/main/OracleDatabase/SingleInstance/samples/client-examples/podman-compose/compose.yaml) uses the `oracle_pwd` Podman secret created in the Quick start. Download it: ```bash curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/podman-compose/compose.yaml -o compose.yaml ``` Start both services, wait for the readiness message, and connect through the running SQLcl container: ```bash podman compose up -d oracle-free sqlcl until podman compose logs oracle-free | grep 'DATABASE IS READY TO USE!'; do sleep 1; done podman compose exec sqlcl sql pdbadmin@//oracle-free:1521/FREEPDB1 ``` SQLcl prompts for the database password. Use `oracle-free`, not `localhost`, as the database host because both services share the Compose network. ### Application container with Podman Compose Add your application as another service under `services` in the same `compose.yaml`: ```yaml application: image: your-application-image:tag depends_on: - oracle-free ``` Configure the application to connect to: ```text Host: oracle-free Port: 1521 Service: FREEPDB1 ``` Start the database, wait for the readiness message, and then start the application: ```bash podman compose up -d oracle-free until podman compose logs oracle-free | grep 'DATABASE IS READY TO USE!'; do sleep 1; done podman compose up -d application ``` ## Optional configuration Pass configuration on the first start of a new database. Settings that affect database creation do not retroactively change an existing data volume. ### Use a versioned image tag The examples use `latest` so they can be copied without first choosing a tag. For repeatable development, testing, and CI environments, replace `latest` or `latest-lite` with a versioned tag from the current registry tag list and use the same tag when recreating the container. `ORACLE_CHARACTERSET` is applied only when the Full image creates a fresh database. It has no effect when `/opt/oracle/oradata` already contains a database. Use a new empty data volume for a different character set. `ORACLE_PDB` is applied only when the Lite image creates a database. It does not rename an existing PDB. | Option | Default | Applies to | Description | | --- | --- | --- | --- | | `ORACLE_CHARACTERSET` | `AL32UTF8` | Full | Character set used when a new database is created | | `ORACLE_PWD` | Randomly generated if omitted | Full and Lite | Password for `SYS`, `SYSTEM`, and `PDBADMIN`; prefer `--secret=oracle_pwd` | | `ENABLE_ARCHIVELOG` | `true` | Full | Enables archive log mode during database creation | | `ENABLE_FORCE_LOGGING` | `true` | Full | Enables force logging during database creation | | `ORACLE_PDB` | `FREEPDB1` | Lite | PDB name used during a new Lite database setup; Full always uses `FREEPDB1` | ### Example configuration Lite image tags include the `-lite` suffix. For example, use `latest` tag for the Full image and `latest-lite` tag for the Lite image. ```bash podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume oracle-free-data:/opt/oracle/oradata \ --env ORACLE_CHARACTERSET=AL32UTF8 \ --env ENABLE_ARCHIVELOG=true \ --env ENABLE_FORCE_LOGGING=true \ container-registry.oracle.com/database/free:latest ``` ### Use a different character set with Full To use a character set other than the default, start Full with a new empty host directory. The empty directory causes a new database setup, so startup can take approximately ten minutes or longer. Do not reuse a volume that already contains a database. ```bash mkdir -p oracle-free-custom-data sudo chown -R 54321:54321 oracle-free-custom-data podman run -d \ --name oracle-free-custom \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume ./oracle-free-custom-data:/opt/oracle/oradata:Z \ --env ORACLE_CHARACTERSET=WE8ISO8859P1 \ container-registry.oracle.com/database/free:latest ``` The example uses `WE8ISO8859P1`; replace it with a supported Oracle character set. Lite does not support changing the database character set. ### Password environment variable fallback For a local-only test where a Podman secret cannot be used, pass the password as an environment variable: ```bash --env ORACLE_PWD='replace-with-password-from-a-local-secret' ``` This can expose the password through container inspection and process tooling. Use `--secret=oracle_pwd` for normal development and shared environments. ### Host port changes If host port `1521` is already used, change only the host side of the mapping: ```bash --publish 1522:1521 ``` Connect to `localhost:1522`; the listener remains on port `1521` inside the container. ## Persist database files ### Recommended: named volume The quick start uses a named volume. Podman creates it automatically when the run command references it: ```bash podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume oracle-free-data:/opt/oracle/oradata \ container-registry.oracle.com/database/free:latest ``` A named volume survives container removal. It is populated with the image's prebuilt database when first mounted, so startup is normally fast. ### Alternative: host directory Use a host directory when you need database files on a specific disk or under an existing backup policy: ```bash mkdir -p data sudo chown -R 54321:54321 data podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume ./data:/opt/oracle/oradata:Z \ container-registry.oracle.com/database/free:latest ``` The `:Z` option applies a private SELinux label on Oracle Linux. If SELinux labeling is not enabled on the host, omit `:Z`. An existing host directory containing database files is reused. An empty host directory hides the prebuilt database at `/opt/oracle/oradata` and starts a new database setup, which can take approximately ten minutes or longer depending on the host. Do not delete or overwrite database files while the container is running. Use database backup tools for backups, and stop the container before maintenance on a host directory. ### Remove storage intentionally Removing the container does not remove a named volume: ```bash podman stop oracle-free podman rm oracle-free ``` The data remains in `oracle-free-data`. Remove it only when the database is no longer needed or has been backed up: ```bash podman volume rm oracle-free-data ``` ## Run setup and startup scripts The Full image supports `.sh` and `.sql` files in: - `/opt/oracle/scripts/setup` — after a new database setup. - `/opt/oracle/scripts/startup` — after the database starts. Prefix filenames with numbers to make order explicit, such as `01_users.sql` and `02_permissions.sql`. SQL scripts run as SYSDBA. Shell scripts run as the current container user. Create the directories: ```bash mkdir -p scripts/setup scripts/startup ``` Mount them when the container is created: ```bash podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --volume oracle-free-data:/opt/oracle/oradata \ --volume ./scripts/setup:/opt/oracle/scripts/setup:ro \ --volume ./scripts/startup:/opt/oracle/scripts/startup:ro \ container-registry.oracle.com/database/free:latest ``` On an SELinux-enabled host, add `:Z` to each host-directory mount, for example `./scripts/startup:/opt/oracle/scripts/startup:ro,Z`. Setup scripts do not run when the image reuses its prebuilt database. They run when an empty data directory causes a new database setup. Startup scripts run after startup in both cases. ## Change database passwords The quick start sets `SYS`, `SYSTEM`, and `PDBADMIN` to the password supplied in `oracle_pwd`. To change those passwords on a running container, use the image's helper script. The helper receives the new password as a process argument, so use this only from a trusted local terminal: ```bash printf 'New database password: ' read -r -s NEW_PASSWORD podman exec oracle-free /opt/oracle/setPassword.sh "$NEW_PASSWORD" unset NEW_PASSWORD ``` Replacing a Podman secret does not change an existing database password. Run the helper, then recreate the Podman secret and container when you want future container recreations to use the new password. ### Encrypted password secret For a shared or production-like host, keep the password encrypted at rest and pass the key separately. Use this procedure instead of the plain-secret procedure in Quick start step 1. The image reads the password secret `oracle_pwd` and the private-key secret `oracle_pwd_privkey`. If you already created a plain `oracle_pwd` secret, stop and remove any container that uses it before replacing the secret. Then remove the old secret with `podman secret rm oracle_pwd`. Podman does not replace a secret in place. Run the encrypted-password sample script: ```bash bash -c "$(curl -fsSL https://raw.githubusercontent.com/oracle/docker-images/main/OracleDatabase/SingleInstance/samples/client-examples/secrets/create-encrypted-password-secrets.sh)" ``` The script generates the key pair and encrypted password in a protected temporary directory, creates `oracle_pwd` and `oracle_pwd_privkey`, and removes the temporary material when it exits. Start the container with both secrets: ```bash podman run -d \ --name oracle-free \ --publish 1521:1521 \ --secret=oracle_pwd \ --secret=oracle_pwd_privkey \ --volume oracle-free-data:/opt/oracle/oradata \ container-registry.oracle.com/database/free:latest ``` Use the exact secret names shown above. A plain `oracle_pwd` secret is sufficient for the quick start; the private-key secret is required only when `oracle_pwd` contains an encrypted password. ## Manage the container ### View status and logs ```bash podman ps --filter name=oracle-free podman logs --tail=200 oracle-free ``` ### Stop, start, and restart Stopping the container keeps the named volume: ```bash podman stop oracle-free podman start oracle-free podman restart oracle-free ``` ### Remove the container but keep the data ```bash podman stop oracle-free podman rm oracle-free ``` Recreate it later with the same volume name. ### Remove the container and data This permanently deletes the database files in the named volume: ```bash podman stop oracle-free podman rm oracle-free podman volume rm oracle-free-data ``` ## Lite image limitations Lite is intended for smaller and simpler deployments. The following features are not supported: - Database - Oracle XML DB - Oracle Database Multilingual Engine (MLE) - Oracle Secure Backup (OSB) - Oracle Memory Speed (OMS) - Oracle SQL access to Kafka - Oracle File Mapping (ORAMAP) - Online Analytical Processing (OLAP) - Oracle DBNest - Database File System (DBFS) - Oracle Heterogeneous Services - Oracle Internet Directory - Oracle External Job Scheduler - Non-Volatile Memory (NVM) support - Oracle Data Pump - Oracle Summary Advisor - Oracle Notifications Service (ONS) - Oracle Embedded R Execution - Oracle I/O Numbers - PL/SQL Server Pages (PSP) - PL/SQL Hierarchical Profiler - PL/SQL native compilation - Oracle Text Knowledge Base Extension Compiler - Oracle Text Lexical Compiler - Oracle Text lexers other than `BASIC_LEXER` - Availability and scalability - Oracle True Cache - Oracle Sharding - Oracle Recovery Manager (RMAN) - Diagnostics - Autonomous Health Framework (AHF) - Automatic Diagnostic Repository - Oracle Trace File Analyzer - Oracle Big Data SQL Diagnostics Collection If an application needs one of these features, use Full and state that requirement in the application's prerequisites. ## Advanced features and integrations ### Oracle True Cache Oracle True Cache is an in-memory, consistent, and automatically managed cache for Oracle AI Database. True Cache requires more than one database container, a shared Podman network, matching password secrets, persistent storage, and service configuration. Do not add `TRUE_CACHE=true` to the one-container quick start. Use the repository's [True Cache extension guide](https://github.com/oracle/docker-images/blob/main/OracleDatabase/SingleInstance/extensions/truecache/README.md) for the supported Full and Free workflows, network setup, secrets, readiness, and service registration. ### Oracle Globally Distributed Database (Oracle GDD) Oracle Globally Distributed Database is a scalability and availability feature for custom-designed OLTP applications that enables the distribution and replication of data across a pool of Oracle Databases that do not share hardware or software. The pool of databases is presented to the application as a single logical database. Use the repository's [Oracle GDD guide](https://github.com/oracle/docker-images/blob/main/OracleDatabase/GDD/samples/container-files/podman-container-files-free/README.md) to deploy an Oracle Globally Distributed Database Container using the Oracle AI Database Free images. ## Troubleshoot | Symptom | What to check | | --- | --- | | Image cannot be pulled automatically | Confirm the image name and tag, network access, and available storage. No database password secret is used for the pull. If the registry presents a terms prompt, complete it and retry `podman run`. | | Container is not healthy | Run `podman logs --tail=500 oracle-free`; check for `DATABASE IS READY TO USE!`, available storage, and volume permissions. | | Startup is slow | Confirm that an empty host directory is not mounted at `/opt/oracle/oradata`. A new database setup takes much longer than reuse of the prebuilt database. | | Host cannot connect | Confirm the container is healthy, the host port is mapped, and the service is `FREEPDB1` for a PDB or `FREE` for a CDB/SYSDBA connection. | | Port `1521` is already in use | Map another host port, such as `--publish 1522:1521`, and connect to `localhost:1522`. | | Application container cannot connect | Put both containers on the same user-defined Podman network and use `oracle-free:1521`, not `localhost:1521`. | | Permission error under `/opt/oracle/oradata` | For a host directory, verify ownership by UID `54321` and review SELinux labeling. | | Secret not found | Confirm that `podman secret ls` contains `oracle_pwd` and that the run command includes `--secret=oracle_pwd`. | | Changing the secret did not change the password | A secret is read during startup; use `/opt/oracle/setPassword.sh` on the running database and recreate the secret for future starts. | | Insufficient space or memory | Confirm at least 13 GB free in container storage and at least 2 GB memory available to the container. | | Architecture mismatch | Use a tag supported by the host architecture or select an explicit `-amd64` or `-arm64` tag from the registry. | When requesting help, include the image tag, host architecture, Podman version, status output, and relevant logs. Redact passwords, tokens, credential-bearing connection strings, private hostnames, and customer data. For database administration and SQL reference, see the [Oracle Database documentation](https://docs.oracle.com/en/database/oracle/oracle-database/index.html). Last updated: 23 September, 2026