Courseiva
CV0-004Chapter 14 of 18Objective 5.1

Cloud Security: Identity and Access Management (IAM)

Cloud Security: Identity and Access Management (IAM). It is the most fundamental control you will configure in the cloud, because without it, you cannot control who gets into your cloud environment or what they can do once inside. For the CV0-004 exam, understanding IAM means understanding how to protect all your cloud resources from the very first moment you create an account.

12 min read
Intermediate
Updated Jul 23, 2026
Reviewed by Johnson Ajibi· Senior Network & Security Engineer · MSc IT Security

A simple way to picture Cloud Security: Identity and Access Management (IAM)

The Office Building Key Card Analogy

Have you ever wondered how a company makes sure that only the right people can get into the right rooms?

Think about a large office building. There is a main entrance with a security guard. Everyone who works there has a photo ID badge with a key card. That badge is your identity. It proves who you are. But the building also has different areas: the server room, the finance office, the CEO's corner office, and the general workspace. Your key card is programmed differently depending on your job. The intern's card might only open the front door and the break room. An accountant's card opens the finance office and their desk area. The IT manager's card opens the server room. The CEO's card opens everything. The security guard at the front desk checks your badge to let you in (authentication), but the locks on every internal door check your badge to see which rooms you are allowed to enter (authorisation). If you try to swipe into the server room without permission, the door stays locked and logs the attempt. This is exactly how Cloud IAM works. The cloud provider is the building. Your username and password are your photo ID. The permissions on your cloud account are the specific doors you can open. The audit log is the security guard's logbook. IAM is the system that issues, manages, and enforces who gets which key card and which doors they can unlock.

How It Actually Works

Identity and Access Management (IAM) is a framework of policies, processes, and technologies that ensures the right people (identities) have the right access to the right cloud resources at the right time, for the right reasons. It is the digital version of the office building key card system.

At its heart, IAM answers three questions: Who are you? What are you allowed to do? And are you actually doing what you are allowed to do? To answer these, IAM relies on three core concepts: authentication, authorisation, and accounting (often called AAA).

Authentication is the process of verifying that you are who you claim to be. It is the 'who are you?' question. You prove your identity using something you know (a password), something you have (a phone with an authenticator app), or something you are (your fingerprint). When you log into a cloud provider like AWS, Azure, or Google Cloud, you authenticate first. The cloud checks your username and password. If they match what is stored, you are authenticated. This is the same as showing your photo ID to the security guard.

Authorisation happens after authentication. It answers the 'what are you allowed to do?' question. Once the cloud knows who you are, it checks a set of rules — called policies — to determine what actions you can perform. For example, you might be authenticated as an employee, but your policy says you can only read files in a specific storage bucket, not delete them. You cannot delete the bucket because the policy does not allow it. Authorisation is the lock on the server room door checking your badge.

Accounting (or auditing) is the third piece. It is the process of keeping a record of who did what, when, and where. Every action you take — every file you upload, every virtual machine you start — gets logged. This is critical for security investigations and for meeting compliance requirements. If something goes wrong, you can look at the logs to see exactly which identity performed the action.

IAM introduces two fundamental types of identities: users and groups. A user is a single, unique identity for one person or application. A group is a collection of users. Instead of assigning permissions to every user individually (which is a nightmare to manage), you assign permissions to a group, and then add users to that group. If someone joins the sales team, you add them to the 'sales' group. They automatically inherit the permissions needed for sales. If someone leaves the sales team, you remove them from the group. This is called the principle of least privilege: giving a user only the minimum permissions they need to do their job.

Another critical identity concept in cloud IAM is the service account (sometimes called a 'service principal' or 'system-assigned managed identity'). A service account is an identity created for an application or a service (like a script, a virtual machine, or a serverless function) rather than for a human. For example, an automated backup script needs permission to read a database and write to a storage bucket. You do not give the script a human username and password — that would be insecure. Instead, you create a service account, attach the necessary permissions to it, and configure the script to authenticate using that service account.

Permissions are granted through policies. A policy is a document that explicitly states what actions are allowed or denied on which resources. In cloud IAM, policies are often written in a structured language like JSON. A typical policy might say: "Allow user 'Alice' to 'read' objects in 'bucket-123'." Or: "Deny everyone from 'deleting' the 'database-server'." Policies can be attached to users, groups, or directly to resources.

One of the most important things to understand for CV0-004 is the difference between 'allow' and 'deny' in policies. Most cloud IAM systems use an explicit deny model. This means that if something is explicitly denied by a policy, it overrides any other allow. In other words, even if you have a policy that says 'allow everything', if there is another policy that says 'deny delete on this database', then the delete action is denied. This is a safety mechanism. Also, by default, all actions are implicitly denied. That means if you do not explicitly allow something, it is denied. You must explicitly add an allow statement to grant access.

Finally, IAM replaces older, less secure ways of managing access. In traditional on-premises data centres, you might have had a single shared admin password that everyone used. That was terrible for security because you could not trace who did what. IAM gives every identity its own credentials and its own audit trail. It also enables centralised access management across multiple cloud services. Instead of setting up a separate login for each database, each server, and each application, you define all access in one central IAM system. This is called single sign-on (SSO), but SSO is just one feature of a broader IAM strategy.

High-level structure of a cloud IAM system, showing how identities, policies, and audit logs interact to control access.

Walk-Through

1

Define Identities

First, identify every entity that needs access to the cloud environment. This includes human users (employees, contractors) and non-human entities (applications, scripts, automated tools). For humans, you will create IAM user accounts. For applications, you will create service accounts. Defining the complete list prevents unauthorised access later.

2

Group Identities by Role

Organise the users into IAM groups based on their job function. Common groups include 'developers', 'administrators', 'auditors', and 'read-only-users'. Grouping simplifies permission management because you attach policies to the group, not to each individual. When a user changes roles, you move them to a different group instead of rewriting their permissions.

3

Write and Attach Policies

Create IAM policies that define the exact permissions each group needs. A policy specifies the actions (read, write, delete, etc.) and the resources (specific storage buckets, databases, virtual machines) those actions apply to. Attach the policy to the appropriate group. Use the principle of least privilege: start with the minimal set of permissions and add more only when necessary.

4

Test Access

After configuring policies, test them. Log in as a user from each group and attempt to perform both allowed and disallowed actions. Verify that allowed actions succeed and disallowed actions fail. This step catches misconfigurations before they cause security breaches or block legitimate work.

5

Enable Logging and Monitoring

Turn on cloud logging for all resources to record every access attempt, both successful and failed. Set up alerts for unusual activity, such as multiple failed login attempts or attempts to delete critical resources. Regularly review logs to spot potential security issues or policy gaps.

6

Review and Rotate

Perform periodic access reviews: check each user's current permissions and remove any that are no longer needed. Rotate access keys for service accounts on a regular schedule. This step ensures that even if credentials are compromised, the window of exposure is limited.

What This Looks Like on the Job

Imagine you work as a junior cloud administrator for 'GreenLeaf Organics', a company that sells organic food online. Your boss hands you a new task: you have just received a request from the marketing department. They need a new cloud storage bucket to store promotional video files. Your real-world job is to create a secure, IAM-managed solution that only the marketing team can access.

Here is the step-by-step of what you actually do:

First, you log into the cloud provider's console using your own IAM user account. Your account has administrative permissions, which were granted by a senior admin through a custom policy that says 'allow all actions'. You know this is a very powerful account, so you only use it when necessary.

Second, you open the IAM dashboard and create a new group called 'marketing-team'. You attach a policy to this group that allows read and write access to a specific storage service. You do not attach a policy that allows deleting the storage itself, because you want to prevent accidental deletion.

Third, you create a new storage bucket called 'greenleaf-marketing-videos' and configure it with a bucket policy. This bucket policy specifically allows access only to the 'marketing-team' group. It also denies access to any IP address outside of the company's office network. This is a combination of identity-based policy (the group policy) and resource-based policy (the bucket policy).

Fourth, you add the marketing employees to the 'marketing-team' group. You do this by finding their existing IAM user names in the directory and clicking 'add to group'. You do not need to touch their passwords or their existing permissions. They just inherit the new storage permissions.

Fifth, you test the setup. You log out of your admin account, log in as a test marketing user, and attempt to upload a video file to the bucket. It works. Then you try to delete the bucket itself. The delete fails because the bucket policy denies it, and the group policy never granted it. Finally, you log in as a user from the finance team and try to access the bucket. The access is denied.

You also set up logging. You enable 'cloud logging' on the bucket to track every read and write action. This way, if a video file goes missing, you can check the logs to see exactly who accessed it and when.

The key actions you perform as an IT professional include:

Creating and managing IAM users and groups.

Writing and attaching policies (both identity-based and resource-based).

Enabling multi-factor authentication (MFA) for high-privilege accounts.

Rotating access keys for service accounts.

Reviewing and auditing IAM permissions regularly (a task called 'access review').

Responding to 'access denied' errors by reading the policy evaluation logic.

In a real enterprise, you would also be responsible for integrating IAM with an on-premises directory service (like Microsoft Entra ID) using federation, but for a beginner, the core skill is creating users, groups, and policies.

How CV0-004 Actually Tests This

The CV0-004 exam (objective 5.1) tests your understanding of IAM concepts, not your ability to click through a console. The questions are scenario-based and often present a problem (like 'an employee cannot access a file') and ask you to identify the cause or the correct solution.

The exam loves to test the difference between authentication and authorisation. A typical question might say: 'A user is able to log in to the cloud console, but when they try to read a file in a storage bucket, they get a permission denied error. What is the most likely issue?' The answer is that the user is authenticated (they can log in) but not authorised (they lack the correct policy to read the file). The trap is that beginners often think the problem is with the password or the account status.

Another heavily tested concept is the principle of least privilege. Questions will present a list of permissions and ask which set is the most secure. The correct answer is always the set that grants exactly the permissions needed and nothing more. The trap is a set that includes overly broad permissions like 'Allow all actions' or 'Allow all resources'.

Service accounts are another favourite topic. You will see questions like: 'Which type of identity should you create for an automated backup script?' The correct answer is a service account. The traps are 'user account' (insecure and not designed for scripts) or 'root account' (extremely dangerous).

Policies and their evaluation logic are tested. Specifically, you need to memorise that explicit denies override explicit allows, and that all actions are implicitly denied by default. A question might describe a situation where a user has two policies — one allowing read access to a bucket and one denying read access to that same bucket. The exam asks what happens. The correct answer is that the deny wins.

Common question types include: - 'What is the purpose of IAM groups?' (Answer: to simplify permission management by assigning policies to a collection of users). - 'What does multi-factor authentication (MFA) improve?' (Answer: authentication security by requiring a second form of identity verification). - 'Which document in IAM defines permissions?' (Answer: a policy).

The exam does not ask you to write a policy in JSON, but it does ask you to interpret a simplified policy statement. For example, it might show a policy that says 'Effect: Allow, Action: s3:GetObject, Resource: *' and ask what it does. The correct answer is that it allows read access to all objects in all S3 buckets.

Traps to avoid:

Confusing 'authentication' with 'authorisation'.

Thinking that 'deny' is the same as 'no policy'. Deny is explicit; no policy is implicit denial.

Believing that the admin account (root user) should be used for daily tasks. The exam emphasises using individual IAM users with least privilege.

Thinking that IAM only applies to humans. It applies to services (service accounts) too.

Key definitions to memorise:

Authentication: verifying identity.

Authorisation: verifying permissions.

Accounting: logging actions.

IAM Policy: a set of rules that define permissions.

IAM Group: a collection of users with shared permissions.

Service Account: an identity for a non-human (application or service).

Principle of Least Privilege: granting minimum necessary permissions.

Key Takeaways

IAM is the framework that controls who can authenticate (log in) and what they are authorised to do after logging in.

Authentication verifies identity; authorisation verifies permissions; accounting logs every action for auditing.

Explicit denies always override explicit allows in IAM policy evaluation.

Use groups to manage permissions for multiple users at once, instead of assigning policies one by one.

The principle of least privilege means granting only the minimum permissions necessary for a task.

Service accounts are identities for applications and automated processes, not for human users.

Always enable multi-factor authentication (MFA) for accounts with administrative permissions.

Regularly review IAM policies and access logs to identify and remove unused or excessive permissions.

Easy to Mix Up

These come up on the exam all the time. Here's how to tell them apart.

Authentication

Verifies who you are (identity)

Occurs first in the access process

Uses passwords, MFA, biometrics

Authorisation

Verifies what you can do (permissions)

Occurs after authentication

Uses policies and rules

IAM User

Represents a single person or application

Has its own credentials

Policies can be attached directly

IAM Group

Represents a collection of users

No credentials – users inside it have credentials

Policies attached to group apply to all members

Identity-Based Policy

Attached to a user, group, or role

Grants permissions to that identity to access resources

Commonly used for users and groups

Resource-Based Policy

Attached directly to a resource (e.g., storage bucket)

Defines which identities can access that specific resource

Commonly used for cross-account access

Implicit Deny

Default state: no policy allows the action

Can be overridden by an explicit allow

Does not appear in policy documents

Explicit Deny

A policy specifically states 'Deny' for the action

Overrides any explicit allow

Is written in a policy document

IAM Role

No permanent credentials

Assumed temporarily by a user or service

Used for cross-account access or temporary sessions

IAM User

Has permanent credentials (password or access keys)

Represents a persistent identity

Used for day-to-day access by people or long-running services

Watch Out for These

Mistake

IAM is only about passwords and usernames.

Correct

IAM is much broader: it includes authentication (passwords), authorisation (policies), and accounting (logging). Passwords are just one small part.

Beginners often focus on the login experience and miss the core concept of authorisation, which is what the exam tests most.

Mistake

If a user can log in, they can do everything.

Correct

Logging in only proves identity (authentication). Doing specific actions requires separate permission (authorisation) granted via policies.

This mistake comes from using personal accounts where signing in typically gives full access to your own data. Cloud environments are shared and locked down.

Mistake

Attaching a policy that says 'Allow' to a user is enough to grant access, even if another policy says 'Deny' for the same action.

Correct

An explicit deny always overrides an explicit allow. If a deny policy exists, the action is blocked regardless of any allow policies.

People assume 'allow' is always stronger. In reality, deny is designed as a safety override, which contradicts natural intuition.

Mistake

IAM policies are only for human users.

Correct

IAM policies are also applied to service accounts (for applications, scripts, and services). Non-human identities need permissions too.

Beginners think of IAM as 'user management' rather than 'identity and access management' for all entities that need access.

Mistake

The root user or admin account is the best account to use for everyday tasks.

Correct

The root account should almost never be used for daily tasks. You should create individual IAM users with only the permissions they need (least privilege).

This is a carryover from legacy systems where one admin account was shared. The cloud model prioritises individual accountability and limited blast radius.

Mistake

IAM roles and IAM policies are the same thing.

Correct

A policy is a document that defines permissions. A role is a container for a policy that can be assumed (temporarily) by a user or service. You attach a policy to a role, not directly to the resource in many cases.

The terms 'role' and 'policy' are used interchangeably in everyday language, but in IAM they are distinct concepts with different functions.

Do You Actually Know This?

Reveal each answer, then mark whether you got it right. Score 60%+ to unlock the next chapter.

Frequently Asked Questions

What is the difference between IAM and SSO?

IAM is the entire framework for managing identities and their permissions. SSO (Single Sign-On) is a feature within IAM that lets users log in once using one set of credentials to access multiple cloud services.

Can two users have the same password in IAM?

Technically yes, but not recommended. Each user should have a unique username and password so that actions can be traced back to the specific individual. Using shared passwords breaks accountability and auditing.

What happens if I delete a user who owns a resource in the cloud?

The resource remains. Ownership is usually tied to the account that created it, not the IAM user. Deleting the IAM user does not delete the resource, but the resource may become inaccessible if it relied on the user's permissions.

What is a read-only IAM policy?

A read-only policy allows a user to view resources (like list files, read database contents) but prevents them from creating, modifying, or deleting anything. It is commonly used for auditors or monitoring staff.

How do I give a temporary worker access for only one week?

Create an IAM user for the worker, attach a policy with the minimum necessary permissions, and then manually delete or disable the user account after the week ends. Some cloud providers also support temporary security credentials with an expiration time.

Is MFA always required for IAM?

It is not technically required by the cloud provider, but it is a strong security best practice. For CV0-004, you should know that enabling MFA on admin accounts is a recommended control to prevent unauthorised access if a password is stolen.

What is a resource-based policy?

A resource-based policy is a policy attached directly to a resource (like a storage bucket or a database) that defines who can access that resource. It is different from an identity-based policy, which is attached to a user or group.

Terms Worth Knowing

Keep going

You've finished Cloud Security: Identity and Access Management (IAM). Continue through the CV0-004 study guide to build a complete picture of the exam.

Done with this chapter?