Oracle OCI Architect

OCI’s physical layout sets what failure you can survive. You learn how regions, availability domains and fault domains differ, which services span them, and how to place resources so a single failure stays small.

• Regions, availability domains and fault domains compared
• Which services are regional and which are zonal
• Single-AD regions and what they change
• Spreading instances across fault domains
• Service limits and capacity planning
• Choosing a region: latency, residency, service availability

You build A placement plan that spreads a workload across fault domains and availability domains.

Most outages are small and local. You design tiers that tolerate the loss of a host or a data center: load balancing, health checks, instance pools and databases that fail over on their own.

• Load balancers and health checks
• Stateless tiers and instance pools
• Autoscaling for load and for recovery
• Highly available storage and file shares
• Database failover inside a region
• Finding single points of failure in a design review

You build A highly available three-tier design, with its failure points marked and answered.

Regional loss needs a plan you have rehearsed. You choose among backup and restore, pilot light and warm or hot standby, and use cross-region replication and Full Stack DR to orchestrate the failover.

• DR strategies from backup and restore to active-active
• Cross-region replication of storage and data
• Orchestrating recovery with Full Stack DR
• DNS and traffic steering during failover
• Runbooks, drills and switchover tests
• Costing each DR option against its objectives

You build A DR plan with objectives, an orchestrated failover design and a test schedule.

As estates grow, one network becomes many. You connect VCNs through the dynamic routing gateway, design hub-and-spoke topologies, and control routing and inspection between them.

• Dynamic routing gateway attachments and route tables
• Hub-and-spoke and transit routing designs
• Local and remote VCN peering compared
• Overlapping address ranges and how to avoid them
• Centralized inspection with network firewalls
• Private access to Oracle services

You build A hub-and-spoke network design with route tables for every attachment.

Private links tie OCI to the rest of the estate. You choose between VPN and FastConnect, design redundant paths and dynamic routing, and place links to other clouds, including Google Cloud, in the design.

• Site-to-site VPN and FastConnect compared
• Redundant circuits and failover paths
• BGP routing and route preference
• Connecting to other clouds, including Google Cloud
• DNS across hybrid environments
• Bandwidth, latency and cost trade-offs

You build A hybrid connectivity design with redundancy, routing and a failover test.

No single control is enough. You design identity, network and host protections that back each other up, using compartments and policies, network security groups, firewalls and bastion access.

• Compartment and policy design for least privilege
• Network security groups compared with security lists
• Web application firewall and network firewall placement
• Bastion and privileged access
• Securing workloads and images
• Separation of duties across environments

You build A layered security design for one workload, showing what each layer stops.

Data and keys are what attackers want. You manage encryption keys in a vault, apply Security Zones and Cloud Guard to enforce and to detect, and gather logs that make incidents investigable.

• Vault, master encryption keys and rotation
• Customer-managed keys across services
• Security Zones as guardrails on compartments
• Cloud Guard detectors and responders
• Audit, flow and service logs
• Responding to an incident from the logs

You build A data protection and detection design with keys, zones, detectors and logging.

The database choice shapes everything around it. You compare Autonomous Database, database systems and Exadata options, and design backup, Data Guard and the Autonomous Recovery Service to meet stated objectives.

• Choosing among Autonomous, VM, bare metal and Exadata services
• Scaling compute and storage
• Data Guard topologies and switchover
• Backups with the Autonomous Recovery Service
• Cross-region database recovery
• Database networking and private access
• Licensing and cost considerations

You build A database design that meets set recovery objectives, with the service choice justified.

Moving is a project with its own risks. You assess the source estate, choose a strategy for each workload, and select tools for servers, data and databases that keep downtime within what the business can accept.

• Discovering and assessing the source estate
• Rehost, replatform and refactor choices
• Migrating virtual machines and storage
• Migrating databases with minimal downtime
• Sequencing waves and planning cutover
• Rollback and validation plans

You build A migration plan with waves, tools and cutover steps for a mixed estate.

Few estates move in a day. You design for the long middle period, when applications span OCI and on-premises systems, with shared identity, data flows, name resolution and monitoring.

• Applications that span two environments
• Identity federation between on-premises and OCI
• Data movement and synchronization
• Latency-sensitive dependencies
• Unified monitoring and operations
• Designing the exit from coexistence

You build A coexistence design for an application split between OCI and on-premises.

Repeatable environments need code, and shared environments need rules. You describe OCI resources in Terraform, run them through Resource Manager stacks, and apply tagging, quotas and policies that keep teams in bounds.

• Terraform for OCI resources and modules
• Resource Manager stacks and jobs
• Detecting and correcting configuration drift
• State handling and team workflows
• Tag standards, quotas and budgets
• Policy as code and review gates

You build A Terraform stack that builds a multi-tier environment with tags and quotas.

A design is judged in operation. You set metrics, alarms and logs that show health, use cost analysis and budgets to catch waste, and feed what you learn back into the architecture.

• Metrics, alarms and notifications
• Central logging and log analysis
• Application and database performance monitoring
• Cost analysis, budgets and rightsizing
• Capacity and quota planning
• Operational reviews and runbooks

You build An operations dashboard and alarm set tied to the design’s objectives.

Pull every area into one design and defend it. You build a multi-region platform for a stated business case, then review it as a panel would, weighing each choice against the alternatives you rejected.

• Reading a business case and its constraints
• Producing the reference architecture
• Testing the design against failure scenarios
• Estimating cost and operational load
• Defending choices against alternatives
• Revising the design after review

You build A complete multi-region OCI architecture with a written defense of each major choice.