Professional-Cloud-Security-Engineer Google Cloud Certified - Professional Cloud Security Engineer Free Practice Exam Questions (2026 Updated)

To fulfill the requirements of preserving logs for 12 years and ensuring data residency within European boundaries, the best approach is to use Google Cloud's operations suite (formerly Stackdriver) with a custom log bucket configured in the desired region.

Configure Cloud Logging Agent:

Install and configure the Cloud Logging agent on your Compute Engine instances. This agent collects logs from your application and system and sends them to Google Cloud's operations suite.

Create a Custom Log Bucket:

In the Cloud Logging interface, create a custom log bucket in the EUROPE-WEST1 region. This bucket will store your logs and can be configured with a custom retention period.

Set Custom Retention Policy:

Configure the retention policy for the custom log bucket to 12 years. This ensures that all logs are preserved for the required duration.

Ship Logs to the Custom Log Bucket:

Modify the logging configuration to direct logs from the Cloud Logging agent to the custom log bucket. This can be done through the logging configuration settings in the Cloud Console or by updating the agent configuration files.

This solution minimizes overhead by using managed services and ensures cost-effectiveness by leveraging Cloud Logging's built-in capabilities for log storage and retention management.

References

Cloud Logging Documentation

Creating and Managing Logs Buckets

To comply with the regulation to keep instance logging data within Europe, specifically in the Netherlands (region europe-west4), you need to configure Cloud Logging to ensure that all logs are stored in a specified region. Here are the steps to achieve this:

Create a Cloud Storage Bucket:

Go to the Google Cloud Console.

Navigate to Cloud Storage and create a new bucket.

Set the location type to "Region" and select "europe-west4" as the region.

Configure Log Sink:

Go to the Logging section in the Google Cloud Console.

Create a new log sink and configure it to export logs to the Cloud Storage bucket you just created.

Ensure the sink includes all logs you want to keep within europe-west4.

Verify Configuration:

Ensure that the logs are being exported to the Cloud Storage bucket by checking the contents of the bucket.

This setup ensures that all your logging data remains within the specified region, adhering to compliance requirements.

References

Creating and Managing Log Sinks

Cloud Storage Locations

Google Cloud Directory Sync (GCDS): Install and configure GCDS to synchronize your on-premises Active Directory with Google Cloud Identity. This tool helps in maintaining consistency between your local directory and Google Cloud.

IAM Groups: Create IAM groups in Google Cloud with permissions that correspond to your Active Directory groups. This mapping ensures that users inherit the appropriate permissions based on their AD group membership.

Synchronization: Set up regular synchronization schedules to keep the user and group information up-to-date between your on-premises AD and Google Cloud.

Access Management: Use these IAM groups to manage access to Google Cloud resources, ensuring that permissions are applied consistently and securely. This approach leverages existing AD infrastructure for identity management, providing a seamless integration with Google Cloud. References:

Google Cloud - Google Cloud Directory Sync

Google Cloud - IAM Groups

To use customer-supplied encryption keys (CSEK) for encrypting data on Cloud Storage, follow these steps:

Generate an Encryption Key: Generate a 256-bit AES encryption key. This key should be base64-encoded.

sh

Copy code

openssl rand -base64 32

Upload Object with CSEK: Use the gsutil command-line tool to upload the object to Cloud Storage, specifying the location of the encryption key using the -o option.

gsutil -o "GSUtil:encryption_key=" cp [LOCAL_OBJECT_PATH] gs://[BUCKET_NAME]/

Verify Encryption: After uploading the object, you can verify that it is encrypted using the provided CSEK by checking the object's metadata.

gsutil stat gs://[BUCKET_NAME]/[OBJECT_NAME]

Key Management: Ensure that the encryption key is securely stored and managed. It should not be hard-coded in scripts or applications.

By using the gsutil tool and specifying the encryption key, you ensure that the object is encrypted using the customer-supplied encryption key during the upload process.

Customer-Supplied Encryption Keys (CSEK) Documentation

gsutil Command Line Tool Documentation

Access Google Cloud Console:

Log in to the Google Cloud Console with administrative privileges.

Navigate to the "IAM & Admin" section.

Set Session Length Timeout:

Go to the "Settings" page within IAM & Admin.

Locate the "Session control" settings.

Configure the session length timeout to a shorter duration, such as 15 or 30 minutes. This ensures that user sessions expire automatically after the specified time of inactivity.

Apply and Enforce the Policy:

Save the changes and ensure the new session timeout policy is applied across all users and services.

Communicate the new policy to employees, highlighting the importance of session security and the rationale behind the change.

Additional Security Measures:

Consider implementing additional measures such as automatic screen locks and secure session management practices.

Educate employees on the importance of logging out of their sessions and securing their devices when not in use.

The core security and privacy requirement is to prevent personal data from being used in the training process, which necessitates de-identification. Cloud Data Loss Prevention (DLP), also referred to as Sensitive Data Protection (SDP), is the specific Google Cloud tool for this purpose. The secondary requirement, restricting access, is handled by IAM.

Extracts:

"Sensitive Data Protection (SDP)... De-identification enables you to transform your data to reduce data risk while retaining data utility." (Source 1.4)

"De-identification techniques like encryption, obfuscate raw sensitive identifiers in your data. These techniques let you preserve the utility of your data for joining or analytics, while reducing the risk of handling the data." (Source 1.1)

"DLP provides tools to classify and de-identify sensitive elements or unwanted content within your data... Find and remove sensitive elements from your data before model training." (Source 1.4)

IAM policies are the standard mechanism to satisfy the requirement to "restrict access to the dataset to an authorized subset of people only." Option B combines the precise technical solution for privacy (DLP De-identification) with the necessary access control (IAM).

Set up a Dedicated Interconnect link between the on-premises environment and Google Cloud:

Dedicated Interconnect provides a direct physical connection between your on-premises network and Google's network, which is ideal for high-throughput, low-latency connections.

Request a Dedicated Interconnect from the Google Cloud Console, specifying the required bandwidth and location.

Once provisioned, set up the connection on your on-premises router and configure the BGP sessions to exchange routes with Google Cloud.

Configure private access using the restricted.googleapis.com domains in on-premises DNS configurations:

Configure your on-premises DNS server to resolve Google APIs to restricted.googleapis.com. This ensures that the traffic stays within the Google network and is not exposed to the public internet.

Update your DNS settings to use restricted.googleapis.com for the necessary API endpoints.

This setup ensures that all Google Cloud API traffic is routed through the private link and subject to VPC Service Controls for additional security and compliance.

The problem focuses on securing "super administrator accounts for the organization" when Cloud Identity is synced with Microsoft Entra ID and uses Entra ID for SSO. The key requirements are the principle of least privilege and strong authentication.

Principle of Least Privilege & Dedicated Accounts: Google's best practices strongly recommend creating dedicated, non-federated accounts for super administrators that are distinct from regular user accounts. These accounts should only be used for super administrator tasks and not for daily activities. This segregation ensures that the highest privilege accounts are isolated and adhere to the principle of least privilege by not having combined responsibilities.

Extract Reference: "Designate Organization Administrators... We recommend keeping your super admin account separate from your Organization Administrator group." and "Give super admins a separate account that requires a separate login. For example, user alice@example.com could have a super admin account alice-admin@example.com." and "Use the super admin account only when needed. Delegate administrator tasks to user accounts with limited admin roles. Use the least privilege approach..." (Google Cloud Documentation: "Super administrator account best practices | Resource Manager Documentation" - https://cloud.google.com/resource-manager/docs/super-admin-best-practices)

Strong Authentication (Google 2-Step Verification): Even when using a third-party identity provider like Microsoft Entra ID for most users, Google recommends enforcing Google's own 2-Step Verification for the critical super administrator accounts. This provides a "break-glass" mechanism that is independent of the external IdP. If the Entra ID integration were to fail or become compromised, the Google-managed super administrator accounts, protected by Google's own 2SV, would still be accessible for emergency recovery.

Extract Reference: "Even when using the legacy SSO profile, super admins can't sign in with SSO in these cases: Admin console. When super administrators try to sign in to an SSO-enabled domain via admin.google.com, they must enter their full Google administrator account email address and associated Google password (not their SSO username and password), and click Sign in to directly access the Admin console. Google doesn't redirect them to the SSO sign-in page." (Google Cloud Identity Help: "Super administrator SSO" - https://support.google.com/cloudidentity/answer/6341409) - This highlights that super admin accounts can bypass SSO for direct Admin console access, making Google 's 2SV crucial.

Extract Reference: "It's especially important for super admins to use 2SV because their accounts control access to all business and employee data in the organization. Protect your business with 2-Step Verification. Use security keys for 2-Step Verification." (Cloud Identity Help: "Security best practices for administrator accounts" - https://support.google.com/cloudidentity/answer/9011373)

Options C and D are incorrect because combining "organization administrator" (IAM role for GCP resources) and "super administrator" (Google Workspace/Cloud Identity domain-level control) privileges violates the principle of least privilege. Option A is less secure than B because relying solely on Entra ID's 2SV for super administrators means a compromise of Entra ID or an outage would leave the Google Cloud organization vulnerable without an independent break-glass mechanism.

https://cloud.google.com/logging/docs/export/troubleshoot#errors_exporting_to_cloud_storage

https://cloud.google.com/logging/docs/export/troubleshoot

Unable to grant correct permissions to the destination: Even if the sink was successfully created with the correct service account permissions, this error message displays if the access control model for the Cloud Storage bucket was set to uniform access when the bucket was created. For existing Cloud Storage buckets, you can change the access control model for the first 90 days after bucket creation by using the Permissions tab. For new buckets, select the Fine-grained access control model during bucket creation. For details, see Creating Cloud Storage buckets.

When configuring SAML-based Single Sign-On (SSO) in an organization that's using Active Directory, the general steps would involve setting up a SAML profile, specifying the necessary URLs for sign-in and sign-out processes, uploading an X.509 certificate for secure communication, and setting up the Entity ID and Assertion Consumer Service (ACS) URL in the Identity Provider (which in this case would be Active Directory).

By default, Vertex AI uses a "Service Agent" (a Google-managed service account) which often has broad permissions across the project. To achieve isolation and least privilege, you must use Custom Service Accounts for each training job.

According to Google Cloud Documentation (Use a custom service account for Vertex AI):

"When you perform custom training, you can configure Vertex AI to use a custom service account. This allows you to grant the job only the specific permissions it needs (e.g., access to a specific Cloud Storage bucket) rather than using the default service agent which may have broader access. This is the recommended practice for multi-tenant or highly regulated environments."

Implementation Strategy:

Identity: Create a unique User-Managed Service Account (UMSA) for each specific training workload or team.

Permissions: Grant that UMSA the roles/storage.objectViewer (or Legacy Reader) only on the specific bucket containing the training data.

Job Config: When submitting the Vertex AI job, specify the serviceAccount field in the job request.

Why other options are incorrect:

A is incorrect: Using one custom service account for all jobs still doesn't provide isolation between the jobs themselves.

B and C are incorrect: These use the default service agent, which is shared across the project. If one job is compromised or misconfigured, it could potentially access data intended for other jobs because they share the same identity.

To ensure that an external user cannot gain access to an internal application on Google App Engine even if an employee’s password is compromised, configure Cloud Identity-Aware Proxy (IAP).

Enable IAP:

Go to the Cloud Console, navigate to the App Engine application, and select "Identity-Aware Proxy".

Enable IAP for the application.

Configure Access Policies:

Set up access policies to restrict who can access the application.

Use IAM roles to grant access only to specific users or groups.

Enforce Authentication:

IAP enforces Google authentication, ensuring that users must log in with their GSuite credentials.

Enable Multi-Factor Authentication (MFA):

Enforce 2FA for all GSuite users to add an extra layer of security.

Advantages:

Protection against Compromised Credentials: Even if passwords are compromised, attackers cannot access the application without passing IAP authentication.

Centralized Access Management: Easily manage and monitor access through IAM and IAP policies.

Identity-Aware Proxy Overview

Setting up IAP

Layer 7 attacks like XSS and SQL injection are application-level threats that require a Web Application Firewall (WAF) for protection. Google Cloud Armor provides this functionality, integrated with the load balancer.

Cloud Armor: Google Cloud's distributed denial-of-service (DDoS) and WAF service.

WAF Rules: Cloud Armor offers pre-configured OWASP Top 10 rules, which directly defend against XSS, SQL injection, and other common application vulnerabilities.

Deployment: Cloud Armor security policies are applied to a backend service that is behind an external HTTP(S) Load Balancer.

Extracts:

"Cloud Armor WAF capabilities help protect web applications from the OWASP Top 10 vulnerabilities... This includes rulesets specifically designed to detect and mitigate SQL injection (SQLi) and cross-site scripting (XSS) attacks." (Source 4.1)

"Cloud Armor security policies are implemented at the edge of the Google Cloud network, applied to the backend services of an external HTTP(S) Load Balancer." (Source 4.2)

Option A is close but incomplete; WAF rules are implemented via a security policy (Option D). Option B relies on Adaptive Protection, which is primarily for volumetric DDoS and advanced attacks, but the direct protection for known XSS/SQLi signatures comes from explicit WAF rules.

Google Cloud Logging supports Field-level access control, which allows you to hide specific sensitive fields within a log entry from certain users while still allowing them to see the rest of the log entry.5 This is achieved using Log Views and IAM.

According to Google Cloud Documentation (Configuring field-level access):

"Field-level access control allows you to restrict access to specific fields of LogEntry objects. You can define which fields are sensitive (such as principalEmail) and then grant the logging.fieldAccessor role to specific users or groups.6 Users without this role will see the log entry, but the sensitive fields will be redacted or omitted from their view."

Key Implementation Steps:

Identify Fields: Determine which paths in the JSON payload are sensitive.

Define Access: Use a Log View to define the scope of logs and apply field-level restrictions.7

Grant Permissions: Grant the standard logging.viewer role for general access and the logging.fieldAccessor role ONLY to the security team for the specific sensitive fields.

Why other options are incorrect:

B is incorrect: IAM conditions cannot natively parse and redact specific JSON fields within a log entry at the platform level; they are typically used for resource-level access.

C is incorrect: While excluding fields via a sink works, it is "all or nothing." If you exclude it at the sink, no one (including the security team) will see that data in the destination.

D is incorrect: This is a workaround that only works if the team uses BigQuery for logs. It doesn't solve the problem within the Cloud Logging Logs Explorer itself.

The problem has two key requirements:

All applications must send data to a centralized security service.

Developers need high autonomy over firewall rules within their projects.

Prevent accidental blockage of access to the central security service.

This scenario requires a mechanism to enforce critical network policies at a higher level of the resource hierarchy while still allowing project-level flexibility.

Hierarchical Firewall Policies: Google Cloud's Hierarchical Firewall Policies (HFP) are designed precisely for this purpose. They allow administrators to define firewall rules at the organization or folder level, and these rules are inherited by all projects and VPC networks within that hierarchy. Crucially, HFP rules can be prioritized. Rules with higher priority (lower numerical value) are evaluated first. This means you can create high-priority "allow" rules for critical services that cannot be overridden or blocked by project-level firewall rules.Extract Reference: "Hierarchical firewall policies allow you to define and enforce consistent network security policies across your organization. Policies can be applied at the organization or folder level, and they are inherited by all projects and VPC networks within that hierarchy." and "Rules in a hierarchical firewall policy can take precedence over VPC network firewall rules based on priority. A rule with a lower priority value takes precedence over a rule with a higher priority value." (Google Cloud documentation: https://cloud.google.com/vpc/docs/firewall-policies-overview)

Preventing Accidental Blockage while Allowing Autonomy: By setting a high-priority "allow" rule for the central security service in a hierarchical firewall policy, you guarantee that this traffic will always be permitted, regardless of what project-level firewall rules developers might configure. This ensures the critical connectivity while still allowing developers to manage other, less critical firewall rules within their projects with high autonomy.

Let's evaluate the other options:

A. Deploy a central Secure Web Proxy and connect it to all VPC networks. Create a Secure Web Proxy policy to allow traffic to the central security service. A Secure Web Proxy is for HTTP/S outbound traffic to external web services. The central security service might not be an external web service, and this solution is focused on application-layer proxies, not general network connectivity like sending data to an internal service. Also, it doesn't directly address the challenge of developers blocking access with project-level firewall rules.

C. Create a central project to manage Shared VPC networks which will be accessible to all other projects. Administer all firewall rules centrally within this project. While Shared VPC centralizes network management, it means all firewall rules are administered centrally. This directly contradicts the requirement for developers to have "high autonomy to configure firewall rules within their projects." Shared VPC would centralize too much control for this specific scenario.

D. Use Terraform to automate the creation of the required firewall rule in all projects. Restrict rule change permissions solely to the Terraform service account. This approach automates the creation but doesn't prevent developers from creating conflicting or overriding rules in their projects (unless Terraform is used to manage all rules, again removing autonomy). It also relies on restricting IAM permissions for all firewall rules, which is against the "high autonomy" requirement for developers. Hierarchical firewall policies offer a more robust and native solution for overriding and enforcing specific rules.

Therefore, implementing a hierarchical firewall policy is the most effective solution, as it allows for the enforcement of critical security service connectivity at a higher level, while still granting developers the desired autonomy over their project-specific firewall rules.

The requirement is to establish a network security boundary around a specific service (BigQuery) for resources in a Folder, while allowing the team to manage that boundary. This is the definition of using VPC Service Controls (VPC SC) with scoped policies.

VPC Service Controls (VPC SC): Used to create a service perimeter (a security boundary) around BigQuery and other Google Cloud services, which restricts API access.

Scoped Policy on the Folder: This enforces the boundary exactly at the required Folder level, as opposed to the organization level.

Access Context Manager Editor Role: Access Context Manager is the service that manages VPC SC policies (Service Perimeters and Access Levels). Granting this role on the scoped policy allows the data analytics team to fulfill the requirement to "control the restrictions."

Extracts (Conceptual Basis for VPC SC and Scoped Policies):

"Private Service Connect provides... Explicit authorization. Private Service Connect provides an authorization model that gives consumers and producers granular control, ensuring that only the intended service endpoints and no other resources can connect to a service." (Source 2.4 - VPC SC and PSC share a core architectural concept of explicit, service-oriented boundaries)

Option B is the technical implementation that matches the requirements: using a VPC SC service perimeter (for service restriction) applied as a scoped policy on the folder (for resource hierarchy scope) with Access Context Manager Editor (for team management/control).

Provision a Cloud NAT Instance:

Cloud NAT (Network Address Translation) allows instances without external IP addresses to access the internet securely.

In the Google Cloud Console, navigate to the VPC Network section and select Cloud NAT.

Create a new Cloud NAT configuration, specifying the VPC and region where your Compute Engine VMs are deployed.

Configure Cloud NAT:

Ensure that the Cloud NAT instance is configured to provide outbound internet connectivity for the VMs in your specified subnet.

This setup allows the VMs to access the internet for package updates and external installations without requiring public IP addresses.

Enable Private Google Access:

Private Google Access allows VMs in a subnet to reach Google APIs and services using internal IP addresses.

In the Google Cloud Console, navigate to the VPC Network section and select Subnets.

Edit the subnet used by your Compute Engine VMs and enable Private Google Access.

Update DevOps Scripts:

Ensure that your DevOps scripts are updated to work with the new network configuration.

Test the build process to confirm that the VMs can access necessary resources and complete the build pipeline successfully.

The requirement to ensure the master encryption key material never leaves the on-premises hardware (HSM) and retaining the unilateral ability to revoke access are the defining features of Cloud External Key Manager (Cloud EKM).

Key Residency: Cloud EKM allows you to use encryption keys stored and managed in a supported external key management system, such as an on-premises HSM, for encrypting data in Google Cloud services like BigQuery and Cloud Storage. This ensures the key material remains in your accredited hardware.

Unilateral Control: Since Google Cloud must request the key from the external system for every encryption/decryption operation, revoking access (by disabling the key or revoking Google's access) in the external system immediately renders the data in Google Cloud inaccessible, granting the customer unilateral control.

Extracts:

"Cloud External Key Manager (Cloud EKM) is a cloud service that lets you encrypt data in Google Cloud with keys you manage outside of Google Cloud." (Source 6.1)

"The key material is stored on an external system, such as a Cloud EKM partner or an on-premises HSM, and never leaves that system." (Source 6.1)

"The customer can unilaterally revoke access to the key at the EKM system, making the encrypted data in Google Cloud inaccessible, which is a key requirement for highly regulated industries." (Source 6.2)

https://cloud.google.com/resource-manager/docs/organization-policy/restricting-domains#setting_the_organization_policy

The domain restriction constraint is a type of list constraint. Google Workspace customer IDs can be added and removed from the allowed_values list of a domain restriction constraint. The domain restriction constraint does not support denying values, and an organization policy can't be saved with IDs in the denied_values list. All domains associated with a Google Workspace account listed in the allowed_values will be allowed by the organization policy. All other domains will be denied by the organization policy.