Index
AccessLevel
(message)AccessPolicy
(message)BasicLevel
(message)BasicLevel.ConditionCombiningFunction
(enum)Condition
(message)CustomLevel
(message)DevicePolicy
(message)OsConstraint
(message)ServicePerimeter
(message)ServicePerimeter.PerimeterType
(enum)ServicePerimeterConfig
(message)ServicePerimeterConfig.VpcAccessibleServices
(message)
AccessLevel
An AccessLevel
is a label that can be applied to requests to Google Cloud services, along with a list of requirements necessary for the label to be applied.
Fields | ||
---|---|---|
name |
Required. Resource name for the Access Level. The |
|
title |
Human readable title. Must be unique within the Policy. |
|
description |
Description of the |
|
Union field level . Required. Describes the necessary conditions for the level to apply. level can be only one of the following: |
||
basic |
A |
|
custom |
A |
AccessPolicy
AccessPolicy
is a container for AccessLevels
(which define the necessary attributes to use Google Cloud services) and ServicePerimeters
(which define regions of services able to freely pass data within a perimeter). An access policy is globally visible within an organization, and the restrictions it specifies apply to all projects within an organization.
Fields | |
---|---|
name |
Output only. Resource name of the |
parent |
Required. The parent of this |
title |
Required. Human readable title. Does not affect behavior. |
etag |
Output only. An opaque identifier for the current version of the |
BasicLevel
BasicLevel
is an AccessLevel
using a set of recommended features.
Fields | |
---|---|
conditions[] |
Required. A list of requirements for the |
combining_function |
How the |
ConditionCombiningFunction
Options for how the conditions
list should be combined to determine if this AccessLevel
is applied. Default is AND.
Enums | |
---|---|
AND |
All Conditions must be true for the BasicLevel to be true. |
OR |
If at least one Condition is true, then the BasicLevel is true. |
Condition
A condition necessary for an AccessLevel
to be granted. The Condition is an AND over its fields. So a Condition is true if: 1) the request IP is from one of the listed subnetworks AND 2) the originating device complies with the listed device policy AND 3) all listed access levels are granted AND 4) the request was sent at a time allowed by the DateTimeRestriction.
Fields | |
---|---|
ip_subnetworks[] |
CIDR block IP subnetwork specification. May be IPv4 or IPv6. Note that for a CIDR IP address block, the specified IP address portion must be properly truncated (i.e. all the host bits must be zero) or the input is considered malformed. For example, "192.0.2.0/24" is accepted but "192.0.2.1/24" is not. Similarly, for IPv6, "2001:db8::/32" is accepted whereas "2001:db8::1/32" is not. The originating IP of a request must be in one of the listed subnets in order for this Condition to be true. If empty, all IP addresses are allowed. |
device_policy |
Device specific restrictions, all restrictions must hold for the Condition to be true. If not specified, all devices are allowed. |
required_access_levels[] |
A list of other access levels defined in the same |
negate |
Whether to negate the Condition. If true, the Condition becomes a NAND over its non-empty fields, each field must be false for the Condition overall to be satisfied. Defaults to false. |
members[] |
The request must be made by one of the provided user or service accounts. Groups are not supported. Syntax: |
regions[] |
The request must originate from one of the provided countries/regions. Must be valid ISO 3166-1 alpha-2 codes. |
CustomLevel
CustomLevel
is an AccessLevel
using the Cloud Common Expression Language to represent the necessary conditions for the level to apply to a request. See CEL spec at: https://github.com/google/cel-spec
Fields | |
---|---|
expr |
Required. A Cloud CEL expression evaluating to a boolean. |
DevicePolicy
DevicePolicy
specifies device specific restrictions necessary to acquire a given access level. A DevicePolicy
specifies requirements for requests from devices to be granted access levels, it does not do any enforcement on the device. DevicePolicy
acts as an AND over all specified fields, and each repeated field is an OR over its elements. Any unset fields are ignored. For example, if the proto is { os_type : DESKTOP_WINDOWS, os_type : DESKTOP_LINUX, encryption_status: ENCRYPTED}, then the DevicePolicy will be true for requests originating from encrypted Linux desktops and encrypted Windows desktops.
Fields | |
---|---|
require_screenlock |
Whether or not screenlock is required for the DevicePolicy to be true. Defaults to |
allowed_encryption_statuses[] |
Allowed encryptions statuses, an empty list allows all statuses. |
os_constraints[] |
Allowed OS versions, an empty list allows all types and all versions. |
allowed_device_management_levels[] |
Allowed device management levels, an empty list allows all management levels. |
require_admin_approval |
Whether the device needs to be approved by the customer admin. |
require_corp_owned |
Whether the device needs to be corp owned. |
OsConstraint
A restriction on the OS type and version of devices making requests.
Fields | |
---|---|
os_type |
Required. The allowed OS type. |
minimum_version |
The minimum allowed OS version. If not set, any version of this OS satisfies the constraint. Format: |
require_verified_chrome_os |
Only allows requests from devices with a verified Chrome OS. Verifications includes requirements that the device is enterprise-managed, conformant to domain policies, and the caller has permission to call the API targeted by the request. |
ServicePerimeter
ServicePerimeter
describes a set of Google Cloud resources which can freely import and export data amongst themselves, but not export outside of the ServicePerimeter
. If a request with a source within this ServicePerimeter
has a target outside of the ServicePerimeter
, the request will be blocked. Otherwise the request is allowed. There are two types of Service Perimeter - Regular and Bridge. Regular Service Perimeters cannot overlap, a single Google Cloud project can only belong to a single regular Service Perimeter. Service Perimeter Bridges can contain only Google Cloud projects as members, a single Google Cloud project may belong to multiple Service Perimeter Bridges.
Fields | |
---|---|
name |
Required. Resource name for the ServicePerimeter. The |
title |
Human readable title. Must be unique within the Policy. |
description |
Description of the |
perimeter_type |
Perimeter type indicator. A single project is allowed to be a member of single regular perimeter, but multiple service perimeter bridges. A project cannot be a included in a perimeter bridge without being included in regular perimeter. For perimeter bridges, the restricted service list as well as access level lists must be empty. |
status |
Current ServicePerimeter configuration. Specifies sets of resources, restricted services and access levels that determine perimeter content and boundaries. |
spec |
Proposed (or dry run) ServicePerimeter configuration. This configuration allows to specify and test ServicePerimeter configuration without enforcing actual access restrictions. Only allowed to be set when the "use_explicit_dry_run_spec" flag is set. |
use_explicit_dry_run_spec |
Use explicit dry run spec flag. Ordinarily, a dry-run spec implicitly exists for all Service Perimeters, and that spec is identical to the status for those Service Perimeters. When this flag is set, it inhibits the generation of the implicit spec, thereby allowing the user to explicitly provide a configuration ("spec") to use in a dry-run version of the Service Perimeter. This allows the user to test changes to the enforced config ("status") without actually enforcing them. This testing is done through analyzing the differences between currently enforced and suggested restrictions. use_explicit_dry_run_spec must bet set to True if any of the fields in the spec are set to non-default values. |
PerimeterType
Specifies the type of the Perimeter. There are two types: regular and bridge. Regular Service Perimeter contains resources, access levels, and restricted services. Every resource can be in at most ONE regular Service Perimeter.
In addition to being in a regular service perimeter, a resource can also be in zero or more perimeter bridges. A perimeter bridge only contains resources. Cross project operations are permitted if all effected resources share some perimeter (whether bridge or regular). Perimeter Bridge does not contain access levels or services: those are governed entirely by the regular perimeter that resource is in.
Perimeter Bridges are typically useful when building more complex toplogies with many independent perimeters that need to share some data with a common perimeter, but should not be able to share data among themselves.
Enums | |
---|---|
PERIMETER_TYPE_REGULAR |
Regular Perimeter. |
PERIMETER_TYPE_BRIDGE |
Perimeter Bridge. |
ServicePerimeterConfig
ServicePerimeterConfig
specifies a set of Google Cloud resources that describe specific Service Perimeter configuration.
Fields | |
---|---|
resources[] |
A list of Google Cloud resources that are inside of the service perimeter. Currently only projects are allowed. Format: |
access_levels[] |
A list of |
restricted_services[] |
Google Cloud services that are subject to the Service Perimeter restrictions. For example, if |
vpc_accessible_services |
Configuration for APIs allowed within Perimeter. |
VpcAccessibleServices
Specifies how APIs are allowed to communicate within the Service Perimeter.
Fields | |
---|---|
enable_restriction |
Whether to restrict API calls within the Service Perimeter to the list of APIs specified in 'allowed_services'. |
allowed_services[] |
The list of APIs usable within the Service Perimeter. Must be empty unless 'enable_restriction' is True. You can specify a list of individual services, as well as include the 'RESTRICTED-SERVICES' value, which automatically includes all of the services protected by the perimeter. |