CompTIA Cloud+

Compute comes in several shapes. You size virtual machines, understand images and templates, run containers and an orchestrator, and decide when a function that runs on demand is a better fit.

• Instance families and sizing
• Images, templates and licensing
• Containers and container registries
• Orchestration concepts and clusters
• Serverless functions and their limits
• Matching compute to a workload pattern

You build A compute choice for four workloads, each with sizing, model and a stated reason.

Data in the cloud lives in different forms at different prices. You compare block, file and object storage, plan tiers and replication, and choose between self-managed and managed databases.

• Block, file and object storage
• Storage tiers and lifecycle rules
• Replication and durability
• Relational and non-relational services
• Managed compared with self-managed databases
• Data transfer and egress costs

You build A storage and database plan for an application, with tiering rules and cost estimates.

Cloud networks are defined in software but follow familiar rules. You build virtual networks and subnets, route and filter traffic, balance load and connect cloud environments to offices and each other.

• Virtual networks, subnets and address planning
• Routing, gateways and NAT
• Load balancers and content delivery
• DNS in the cloud
• VPNs and dedicated connections
• Private access to provider services

You build A virtual network design with public and private tiers and a VPN to a branch office.

Architecture is a set of trade-offs. You turn requirements into a design that meets availability, performance and cost targets, and choose a migration approach for existing applications.

• Turning requirements into design decisions
• Designing for availability and fault tolerance
• Performance, latency and caching
• Cost modeling and right-sizing
• Rehost, replatform and refactor
• Documenting the architecture

You build An architecture diagram and decision record for a three-tier web application.

Manual setup does not scale. You describe infrastructure in templates, deploy it repeatably, and choose a rollout method that limits the damage of a bad release.

• Infrastructure defined in templates
• Parameters, state and drift
• Configuration management of new resources
• Rolling, blue-green and canary deployments
• Tagging and naming standards
• Testing a deployment before it goes live

You build A template that deploys a complete environment, redeployed from scratch to prove it works.

Most organizations move systems rather than start fresh. You assess what to move, pick a transfer method, plan the cut-over and a way back, and verify that the moved workload behaves as it did.

• Discovery and dependency mapping
• Online and offline data transfer
• Migrating virtual machines and databases
• Cut-over planning and rollback
• Validation and performance comparison
• Moving between providers

You build A migration plan for one application, with sequence, cut-over window and rollback steps.

Cloud systems change constantly, so you need to see them. You collect metrics, logs and traces, build dashboards, and set alerts that tell the right person something useful.

• Metrics, logs and traces
• Dashboards that answer a question
• Alert rules and escalation paths
• Service level objectives and indicators
• Auditing activity in the account
• Cost visibility and budgets

You build A monitoring dashboard and alert set for a deployed application.

Running well means growing, patching and recovering without drama. You configure automatic scaling, schedule backups and updates, and plan disaster recovery that matches the value of each system.

• Horizontal and vertical scaling
• Autoscaling policies and cooldowns
• Backups, snapshots and retention
• Patching and image maintenance
• Disaster recovery strategies and objectives
• Controlling cost as usage grows

You build A scaling policy, backup schedule and disaster recovery plan for one service.

In the cloud, access is the perimeter. You define identities, roles and policies on the principle of least privilege, protect secrets, and use network controls to limit what can talk to what.

• Identities, groups and roles
• Policies and least privilege
• Multi-factor authentication and federation
• Security groups and network access lists
• Secrets and key storage
• Web application and perimeter protection

You build An access policy set for a development team, with roles, boundaries and a review.

Data must be protected wherever it lands. You classify and encrypt it, manage keys, prevent leaks, and show with logs and posture checks that the environment meets its obligations.

• Data classification and residency
• Encryption at rest and in transit
• Key management and rotation
• Preventing data loss and exposure
• Compliance frameworks and evidence
• Posture management and misconfiguration checks

You build A data protection and compliance checklist applied to a live test environment.

Delivery speed comes from automation. You use source control, build continuous integration and delivery pipelines, treat infrastructure as code, and call cloud services through their APIs.

• Source control for code and infrastructure
• Continuous integration and testing
• Continuous delivery pipelines
• Infrastructure as code workflows
• Working with cloud APIs and command line tools
• Secrets and approvals in pipelines

You build A pipeline that builds, tests and deploys a small application to the cloud.

Problems cross the boundary between your code and the provider’s platform. You diagnose failed deployments, connectivity gaps, capacity and quota limits, licensing issues and security misconfigurations.

• A troubleshooting method for cloud systems
• Deployment and template failures
• Connectivity, routing and DNS problems
• Quotas, capacity and performance limits
• Identity and permission errors
• Integration and licensing issues

You build A troubleshooting guide covering ten common cloud faults, each with a verified fix.

One project uses every skill. You design, deploy, secure, monitor and document a workload, then migrate part of it and recover it from a simulated failure.

• Turning a brief into an architecture
• Deploying it from code
• Securing and monitoring it
• Recovering from a simulated outage
• Reviewing cost and design choices

You build A deployed workload with code, diagrams, monitoring and a recovery test.