| Aspect | Rolling Mode | Non-Rolling Mode |
|--------|--------------|------------------|
| Command flag | -rolling | -nonrolling |
| Service downtime | Minimal (node-by-node) | Entire cluster downtime |
| Cluster operation | Nodes patched sequentially online | Cluster stopped during patch |
| Use case | Most PSUs, RU, one-off patches | First patch, certain critical fixes |
The command opatchauto72030 execute in nonrolling mode is more than a routine maintenance task—it is a surgical operation on Oracle Grid Infrastructure. By understanding when and why to use non‑rolling mode, and adhering to high‑quality best practices (validation, backup, monitoring, and post‑validation), you transform a risky patching window into a predictable, successful maintenance event.
Always remember: Non‑rolling mode trades zero runtime node coexistence for simplicity and mandatory compatibility. Embrace its structure, respect its downtime, and execute with precision.
For further reading, consult Oracle Support Document 244241.1 (Opatchauto FAQ) and the specific README for your patch ID.
The error OPATCHAUTO-72030 typically indicates that the opatchauto utility has detected a shared Oracle Grid Infrastructure (GI) home or a specific configuration (like a single-node GI) that requires a non-rolling patching approach. In a non-rolling mode, all services across the cluster nodes must be stopped simultaneously, leading to downtime for the entire environment. Understanding the Error
Trigger: The utility throws this error when it determines that a "Rolling" update—where nodes are patched one by one while others remain active—is not possible or allowed.
Root Cause: Often occurs when the CRS (Cluster Ready Services) home is shared across nodes or when a mandatory validation (introduced in versions like 12.2.0.1.10) enforces the -nonrolling flag for single-node setups.
Permissions & Environment: Ensure you are not running the command from restricted directories like /root or / and that the home owner has write permissions to the current directory. Execution Procedure for Non-Rolling Mode
To resolve the error and successfully apply the patch, you must explicitly use the -nonrolling flag. Follow these steps: Preparation:
Download the latest OPatch utility (Patch 6880880) to ensure compatibility.
Verify prerequisites by running the command with the -analyze flag first. Service Shutdown:
Stop the Grid Infrastructure stack and all databases on all nodes in the cluster.
The local node where you execute the command must have the stack down for non-rolling sessions to proceed. Command Execution:
Run the following command as the root user from the GI home:
# / Use code with caution. Copied to clipboard Comparison: Rolling vs. Non-Rolling OPATCHAUTO-72141: Execute opatchauto in non-rolling mode.
Understanding OPATCHAUTO-72030: Mastering Non-Rolling Mode Patching
The error OPATCHAUTO-72030 typically occurs during Oracle Grid Infrastructure (GI) patching when the utility detects a configuration—such as a shared CRS home—that is incompatible with standard rolling mode. This error is a safeguard, informing the user that the patching session cannot proceed unless it is explicitly executed in non-rolling mode. Why Does OPATCHAUTO-72030 Occur?
Oracle's opatchauto utility defaults to rolling mode, which patches one node at a time while keeping the cluster operational. However, certain environments require a full cluster shutdown:
Shared Grid Homes: If the CRS (Cluster Ready Services) home is shared across multiple nodes, it cannot be patched while other nodes are still using it.
Non-Rollable Patches: Some specific patches contain changes that do not support different versions running simultaneously across the cluster.
Single-Node GI: In some software versions (e.g., 12.2.0.1.10), a bug or specific validation might force the use of the -nonrolling flag even on single-node setups. How to Execute Patching in Non-Rolling Mode
To resolve error 72030 and successfully apply your patch, you must use the -nonrolling parameter. 1. Prepare the Environment Rocky Linux release 8.8 19c rac ru安装 - 墨天轮
The error OPATCHAUTO-72030 typically indicates that opatchauto cannot execute a patch in rolling mode because the Grid Infrastructure (GI) home is shared across nodes.
In a shared home environment, the software binaries are physically located on a shared disk rather than individual local disks for each node. Because patching these binaries affects all nodes simultaneously, a standard "rolling" update—where one node stays up while another is patched—is technically impossible. The "Non-Rolling Mode" Requirement
To resolve this, you must explicitly use the -nonrolling flag in your command.
Execution Command:# High-Quality/High-Availability Impact: opatchauto72030 execute in nonrolling mode high quality
Downtime: Unlike rolling mode (zero downtime), non-rolling mode requires taking a complete outage for all nodes in the cluster simultaneously.
Efficiency: While it causes downtime, it is often faster for the overall maintenance window because patches are applied to the shared binaries once rather than node-by-node.
Best Practice: For high-availability systems, it is recommended to move workloads to a standby system (e.g., via Data Guard) before initiating a non-rolling patch session. Comparison: Rolling vs. Non-Rolling Rolling Mode (Default) Non-Rolling Mode (-nonrolling) Availability Continuous; services stay up on other nodes. Complete outage required; all nodes down. Compatibility Only for local/non-shared homes. Required for shared homes or non-rollable patches. Complexity Node-by-node sequential execution. Parallel/Simultaneous execution on shared binaries.
Are you currently encountering this error during an analyze run or a live apply session? Doc ID 2957442.1 OPATCHAUTO-72030 During Opatchauto
When maintaining Oracle Grid Infrastructure (GI) and Real Application Clusters (RAC), the error OPATCHAUTO-72030: Execute in non-rolling mode typically serves as a mandatory system instruction rather than a simple failure. This error occurs when the opatchauto utility detects a configuration—such as a shared GI home or a non-rollable patch—that prevents the default sequential, rolling update process. Successfully navigating this requires transitioning to a non-rolling execution strategy to ensure the integrity of the cluster. Understanding the OPATCHAUTO-72030 Trigger
The core reason for this error is often a structural requirement of the Oracle environment:
Shared Homes: If the GI or Database home is shared across multiple nodes, it cannot be patched in a rolling fashion because the underlying binaries are being accessed by active instances on other nodes.
Non-Rollable Patch Content: Some patches contain metadata that explicitly forbids rolling updates to prevent version mismatches between cluster nodes during the process.
Fix for Known Bugs: In some versions, such as 12.2.0.1.10, Oracle added validations that force the use of the -nonrolling flag for single-node GI environments to avoid orchestration conflicts. High-Quality Execution in Non-Rolling Mode
To resolve OPATCHAUTO-72030 and apply the patch with high quality, the process must shift from a node-by-node update to a coordinated cluster-wide downtime event. 1. Pre-Execution Validation
Before applying the patch, run a simulation to catch potential issues without altering the system:
Analyze Command: Use opatchauto apply to run all prerequisite checks, including space and inventory validations.
Inventory Verification: Confirm all nodes are at the same patch level using opatch lsinventory before starting. 2. Service Management
Non-rolling mode requires a specific state for cluster services:
Local Node: The GI stack must be up on the local node where you execute the command.
Remote Nodes: All remote nodes must have their services stopped completely.
Explicit Flag: You must include the -nonrolling argument in your command. 3. Execution Sequence
Following the refined 12c+ orchestration logic, the non-rolling session typically follows these phases:
Phase 1: Execute opatchauto apply on the first node. Phase 2: Patch intermediate nodes (nodes 2 through ) in parallel.
Phase 3: Patch the final node to complete the session and finalize the cluster-wide configuration. Post-Patching Verification Once opatchauto completes, quality assurance involves:
Log Review: Check the session logs for any warnings, particularly regarding datapatch or sqlpatch.
Manual SQL Application: For non-rollable patches, databases must be brought back up so you can manually run the Datapatch Utility on the last node to load modified SQL files into the database.
Final Inventory: Re-run opatch lsinventory on every node to confirm the new patch ID is listed. Non-Rolling upgrade in RAC using opatchauto - Oracle Forums
The error OPATCHAUTO-72030 indicates that opatchauto cannot execute in its default "rolling" mode, typically because the Grid Infrastructure (GI) home is shared. In shared home configurations, patching one node affects all nodes simultaneously, making the node-by-node rolling process impossible.
To resolve this and ensure a high-quality execution, you must explicitly use the -nonrolling flag. Execution Steps for Non-Rolling Mode | Aspect | Rolling Mode | Non-Rolling Mode
For a high-quality, stable patching session, follow these steps as the root user:
Stop Remote Nodes: In a multi-node environment, all remote nodes must be shut down before starting the session.
Verify Local Stack: The Oracle Grid Infrastructure stack must be up and running on the local node (the node where you initiate the command).
Run the Command: Navigate to your patch directory and execute the following:
# / Use code with caution. Copied to clipboard
Note: Ensure you are not running this from the /root or / directory to avoid permission issues. Troubleshooting and Best Practices Rocky Linux release 8.8 19c rac ru安装 - 墨天轮
When maintaining Oracle Grid Infrastructure (GI) or RAC environments, you may encounter the requirement to use the -nonrolling opatchauto
. This is often triggered by specific patch constraints or the OPATCHAUTO-72030
error, which serves as a directive from the utility that the current environment state or patch content does not support a rolling application. Understanding the Non-Rolling Mode By default, opatchauto operates in rolling mode
, patching one node at a time while keeping the cluster operational. In contrast, non-rolling mode
requires a coordinated shutdown of services across the cluster to apply patches that might otherwise cause version conflicts during a phased rollout. Downtime Requirement:
All remote nodes must be down to start a non-rolling session. Execution Order:
You patch a single node (the local node) first, followed by others. Version 12c+ Behavior:
Starting with 12c, non-rolling patching requires the GI stack to be up on the local node being patched, while all other nodes are shut down. Resolving OPATCHAUTO-72030 OPATCHAUTO-72030
error typically occurs when the tool detects that a rolling update is not feasible—often because the cluster is already in an inconsistent state or the patch itself is "non-rollable". Stop Remote Nodes:
Ensure all remote nodes in the cluster are completely shut down before execution. Verify Local Node:
The local GI stack must be active on the node where you are running the command. Execute with Flag: Use the explicit -nonrolling parameter as shown in this 12c GI PSU Guide # opatchauto apply
To ensure a successful execution and avoid common pitfalls, follow this structured workflow: 1. Preparation and Health Checks Download Latest OPatch: Ensure you have the latest version of the OPatch utility for your specific Oracle release. Analyze First: Run the command with the
flag to simulate the process and identify prerequisite failures without modifying the system. Verify Permissions: opatchauto from a directory other than to avoid write permission errors, as noted in troubleshooting logs 2. The Patching Workflow Concepts of Multi-Node Patch Orchestration Using OPatchAuto
In the world of Oracle Database administration, OPATCHAUTO-72030 is a specific error that occurs when a DBA attempts to patch a shared Oracle Grid Infrastructure (GI) home in the default "rolling" mode. Here is the story of how a DBA resolves this challenge. The Midnight Maintenance
It was 2 AM on a Tuesday. Alex, a Senior DBA, was tasked with applying the latest Release Update to a 2-node RAC cluster. The goal was simple: use opatchauto to automate the heavy lifting. Alex typed the standard command: # opatchauto apply /u01/app/oracle/patches/35319490
Within seconds, the terminal spat back a wall of red text:OPATCHAUTO-72030: Cannot execute in rolling mode, as CRS home is shared. The Realisation
Alex remembered the rule: shared Grid Infrastructure homes cannot be patched one node at a time while the others stay online. Unlike a standard setup where each node has its own local binaries, a shared home is an "all or nothing" situation. To proceed, the entire cluster had to go dark. The "Non-Rolling" Strategy
To fix this, Alex followed the Non-Rolling protocol, which requires a specific sequence to ensure the shared binaries are updated without corruption:
Preparation: Alex notified the application teams of a complete cluster outage. For further reading, consult Oracle Support Document 244241
Stopping Remote Nodes: Per Oracle’s strict requirements for non-rolling sessions, all remote nodes must be stopped. Alex logged into Node 2 and shut down the stack.
Local Node Status: Interestingly, starting with 12c, the local node (Node 1) must remain up to initiate the session, even in non-rolling mode.
The Correct Command: Alex re-ran the command, but this time added the critical flag:# opatchauto apply /u01/app/oracle/patches/35319490 -nonrolling Success and Verification
The orchestration engine hummed to life. Instead of trying to keep services alive, opatchauto systematically applied the bits across the shared infrastructure. Once the session completed, Alex verified the work:
Executing Opatchauto in Non-Rolling Mode: A High-Quality Guide
Opatchauto is a powerful tool used in Oracle environments to automate the application of patches to Oracle databases and other Oracle products. It simplifies the patching process, making it more efficient and reducing the risk of human error. One of the key features of opatchauto is its ability to execute in non-rolling mode, which is particularly useful in certain scenarios. In this article, we will explore the concept of executing opatchauto in non-rolling mode, its benefits, and provide a step-by-step guide on how to do it with high quality.
What is Opatchauto?
Opatchauto is a command-line utility developed by Oracle Corporation to automate the patching process for Oracle databases and other Oracle products. It is designed to simplify the application of patches, making it easier to keep your Oracle environment up-to-date and secure. Opatchauto is a part of the Oracle Patch Automation Tool (OPatch) and is widely used by Oracle administrators and database engineers.
What is Non-Rolling Mode?
In opatchauto, non-rolling mode refers to the ability to apply patches to a Oracle database or product without restarting the database or service. This mode is particularly useful in production environments where downtime is not acceptable or feasible. In non-rolling mode, opatchauto applies patches to the database or product while it is still online, ensuring minimal disruption to users and applications.
Benefits of Executing Opatchauto in Non-Rolling Mode
Executing opatchauto in non-rolling mode offers several benefits, including:
Prerequisites for Executing Opatchauto in Non-Rolling Mode
Before executing opatchauto in non-rolling mode, ensure that the following prerequisites are met:
Step-by-Step Guide to Executing Opatchauto in Non-Rolling Mode
To execute opatchauto in non-rolling mode, follow these steps:
Example:
opatchauto.sh -nonrolling -bundle /path/to/patch_bundle.zip
Best Practices for Executing Opatchauto in Non-Rolling Mode
To ensure high quality and minimize risks when executing opatchauto in non-rolling mode, follow these best practices:
Conclusion
Executing opatchauto in non-rolling mode is a powerful feature that allows patches to be applied to Oracle databases and products with minimal disruption. By following the prerequisites, step-by-step guide, and best practices outlined in this article, you can ensure high-quality patching with opatchauto in non-rolling mode. Remember to test patches, backup your database, monitor performance, and verify patch levels to minimize risks and ensure a smooth patching process.
References
opatch lspatches
SELECT PATCH_ID, VERSION, STATUS FROM DBA_REGISTRY_SQLPATCH;
| Pitfall | Solution |
|--------|----------|
| Running as wrong OS user | Always run opatchauto as the Grid home owner (grid), not oracle. |
| Missing shared storage access | Ensure all nodes can access the same staged patch directory (e.g., NFS, ACFS). |
| Rolling mode forced by default | Explicitly use -nonrolling; otherwise, opatchauto may default to rolling for RAC. |
| Interrupted execution | Do not Ctrl+C. Use opatchauto resume if supported; otherwise, roll back using -rollback. |
| SQL patch failures | Run datapatch -verbose manually after successful binary patching. |