Cloud

Types:

from gcore.types.cloud import (
    AllowedAddressPairs,
    BaremetalFlavor,
    BaremetalFlavorList,
    BlackholePort,
    Console,
    DDOSProfile,
    DDOSProfileField,
    DDOSProfileOptionList,
    DDOSProfileStatus,
    DDOSProfileTemplate,
    DDOSProfileTemplateField,
    FixedAddress,
    FixedAddressShort,
    FlavorHardwareDescription,
    FloatingAddress,
    FloatingIP,
    FloatingIPStatus,
    GPUImage,
    GPUImageList,
    HTTPMethod,
    Image,
    ImageList,
    Instance,
    InstanceIsolation,
    InstanceList,
    InstanceMetricsTimeUnit,
    InterfaceIPFamily,
    IPAssignment,
    IPVersion,
    LaasIndexRetentionPolicy,
    LoadBalancer,
    LoadBalancerInstanceRole,
    LoadBalancerMemberConnectivity,
    LoadBalancerOperatingStatus,
    LoadBalancerStatistics,
    Logging,
    Network,
    NetworkAnySubnetFip,
    NetworkDetails,
    NetworkInterface,
    NetworkInterfaceList,
    NetworkSubnetFip,
    ProvisioningStatus,
    Route,
    Subnet,
    Tag,
    TagList,
    TagUpdateMap,
    TaskIDList,
)

Projects

Types:

from gcore.types.cloud import Project

Methods:

client.cloud.projects.create(**params) -> Project
client.cloud.projects.update(*, project_id, **params) -> Project
client.cloud.projects.list(**params) -> SyncOffsetPage[Project]
client.cloud.projects.delete(*, project_id) -> TaskIDList
client.cloud.projects.get(*, project_id) -> Project

Tasks

Types:

from gcore.types.cloud import Task

Methods:

client.cloud.tasks.list(**params) -> SyncOffsetPage[Task]
client.cloud.tasks.acknowledge_all(**params) -> None
client.cloud.tasks.acknowledge_one(task_id) -> Task
client.cloud.tasks.get(task_id) -> Task

Regions

Types:

from gcore.types.cloud import Region

Methods:

client.cloud.regions.list(**params) -> SyncOffsetPage[Region]
client.cloud.regions.get(*, region_id, **params) -> Region

Quotas

Types:

from gcore.types.cloud import QuotaGetAllResponse, QuotaGetByRegionResponse, QuotaGetGlobalResponse

Methods:

client.cloud.quotas.get_all() -> QuotaGetAllResponse
client.cloud.quotas.get_by_region(*, client_id, region_id) -> QuotaGetByRegionResponse
client.cloud.quotas.get_global(client_id) -> QuotaGetGlobalResponse

Requests

Types:

from gcore.types.cloud.quotas import RequestListResponse, RequestGetResponse

Methods:

client.cloud.quotas.requests.create(**params) -> None
client.cloud.quotas.requests.list(**params) -> SyncOffsetPage[RequestListResponse]
client.cloud.quotas.requests.delete(request_id) -> None
client.cloud.quotas.requests.get(request_id) -> RequestGetResponse

Secrets

Types:

from gcore.types.cloud import Secret

Methods:

client.cloud.secrets.list(*, project_id, region_id, **params) -> SyncOffsetPage[Secret]
client.cloud.secrets.delete(secret_id, *, project_id, region_id) -> TaskIDList
client.cloud.secrets.get(secret_id, *, project_id, region_id) -> Secret
client.cloud.secrets.upload_tls_certificate(*, project_id, region_id, **params) -> TaskIDList

SSHKeys

Types:

from gcore.types.cloud import SSHKey, SSHKeyCreated

Methods:

client.cloud.ssh_keys.create(*, project_id, **params) -> SSHKeyCreated
client.cloud.ssh_keys.update(ssh_key_id, *, project_id, **params) -> SSHKey
client.cloud.ssh_keys.list(*, project_id, **params) -> SyncOffsetPage[SSHKey]
client.cloud.ssh_keys.delete(ssh_key_id, *, project_id) -> None
client.cloud.ssh_keys.get(ssh_key_id, *, project_id) -> SSHKey

IPRanges

Types:

from gcore.types.cloud import IPRanges

Methods:

client.cloud.ip_ranges.list() -> IPRanges

LoadBalancers

Types:

from gcore.types.cloud import (
    HealthMonitor,
    HealthMonitorStatus,
    LbAlgorithm,
    LbHealthMonitorType,
    LbListenerProtocol,
    LbPoolProtocol,
    LbSessionPersistenceType,
    ListenerStatus,
    LoadBalancerFlavorDetail,
    LoadBalancerFlavorList,
    LoadBalancerL7Policy,
    LoadBalancerL7PolicyList,
    LoadBalancerL7Rule,
    LoadBalancerL7RuleList,
    LoadBalancerListenerDetail,
    LoadBalancerListenerList,
    LoadBalancerMetrics,
    LoadBalancerMetricsList,
    LoadBalancerPool,
    LoadBalancerPoolList,
    LoadBalancerStatus,
    LoadBalancerStatusList,
    Member,
    MemberStatus,
    PoolStatus,
    SessionPersistence,
)

Methods:

client.cloud.load_balancers.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.update(load_balancer_id, *, project_id, region_id, **params) -> LoadBalancer
client.cloud.load_balancers.list(*, project_id, region_id, **params) -> SyncOffsetPage[LoadBalancer]
client.cloud.load_balancers.delete(load_balancer_id, *, project_id, region_id) -> TaskIDList
client.cloud.load_balancers.failover(load_balancer_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.get(load_balancer_id, *, project_id, region_id, **params) -> LoadBalancer
client.cloud.load_balancers.resize(load_balancer_id, *, project_id, region_id, **params) -> TaskIDList

L7Policies

Methods:

client.cloud.load_balancers.l7_policies.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.l7_policies.update(l7policy_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.l7_policies.list(*, project_id, region_id) -> LoadBalancerL7PolicyList
client.cloud.load_balancers.l7_policies.delete(l7policy_id, *, project_id, region_id) -> TaskIDList
client.cloud.load_balancers.l7_policies.get(l7policy_id, *, project_id, region_id) -> LoadBalancerL7Policy

Rules

Methods:

client.cloud.load_balancers.l7_policies.rules.create(l7policy_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.l7_policies.rules.list(l7policy_id, *, project_id, region_id) -> LoadBalancerL7RuleList
client.cloud.load_balancers.l7_policies.rules.delete(l7rule_id, *, project_id, region_id, l7policy_id) -> TaskIDList
client.cloud.load_balancers.l7_policies.rules.get(l7rule_id, *, project_id, region_id, l7policy_id) -> LoadBalancerL7Rule
client.cloud.load_balancers.l7_policies.rules.replace(l7rule_id, *, project_id, region_id, l7policy_id, **params) -> TaskIDList

Flavors

Methods:

client.cloud.load_balancers.flavors.list(*, project_id, region_id, **params) -> LoadBalancerFlavorList

Listeners

Methods:

client.cloud.load_balancers.listeners.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.listeners.update(listener_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.listeners.list(*, project_id, region_id, **params) -> LoadBalancerListenerList
client.cloud.load_balancers.listeners.delete(listener_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.listeners.get(listener_id, *, project_id, region_id, **params) -> LoadBalancerListenerDetail

Pools

Methods:

client.cloud.load_balancers.pools.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.pools.update(pool_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.pools.list(*, project_id, region_id, **params) -> LoadBalancerPoolList
client.cloud.load_balancers.pools.delete(pool_id, *, project_id, region_id) -> TaskIDList
client.cloud.load_balancers.pools.get(pool_id, *, project_id, region_id) -> LoadBalancerPool

HealthMonitors

Methods:

client.cloud.load_balancers.pools.health_monitors.create(pool_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.pools.health_monitors.delete(pool_id, *, project_id, region_id) -> None

Members

Methods:

client.cloud.load_balancers.pools.members.create(pool_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.load_balancers.pools.members.delete(member_id, *, project_id, region_id, pool_id) -> TaskIDList

Metrics

Methods:

client.cloud.load_balancers.metrics.list(load_balancer_id, *, project_id, region_id, **params) -> LoadBalancerMetricsList

Statuses

Methods:

client.cloud.load_balancers.statuses.list(*, project_id, region_id) -> LoadBalancerStatusList
client.cloud.load_balancers.statuses.get(load_balancer_id, *, project_id, region_id) -> LoadBalancerStatus

ReservedFixedIPs

Types:

from gcore.types.cloud import ReservedFixedIP

Methods:

client.cloud.reserved_fixed_ips.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.reserved_fixed_ips.update(port_id, *, project_id, region_id, **params) -> ReservedFixedIP
client.cloud.reserved_fixed_ips.list(*, project_id, region_id, **params) -> SyncOffsetPage[ReservedFixedIP]
client.cloud.reserved_fixed_ips.delete(port_id, *, project_id, region_id) -> TaskIDList
client.cloud.reserved_fixed_ips.get(port_id, *, project_id, region_id) -> ReservedFixedIP

Vip

Types:

from gcore.types.cloud.reserved_fixed_ips import IPWithSubnet

Methods:

client.cloud.reserved_fixed_ips.vip.toggle(port_id, *, project_id, region_id, **params) -> ReservedFixedIP

CandidatePorts

Types:

from gcore.types.cloud.reserved_fixed_ips.vip import CandidatePort, CandidatePortList

Methods:

client.cloud.reserved_fixed_ips.vip.candidate_ports.list(port_id, *, project_id, region_id) -> CandidatePortList

ConnectedPorts

Types:

from gcore.types.cloud.reserved_fixed_ips.vip import ConnectedPort, ConnectedPortList

Methods:

client.cloud.reserved_fixed_ips.vip.connected_ports.list(port_id, *, project_id, region_id) -> ConnectedPortList
client.cloud.reserved_fixed_ips.vip.connected_ports.add(port_id, *, project_id, region_id, **params) -> ConnectedPortList
client.cloud.reserved_fixed_ips.vip.connected_ports.replace(port_id, *, project_id, region_id, **params) -> ConnectedPortList

Networks

Methods:

client.cloud.networks.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.networks.update(network_id, *, project_id, region_id, **params) -> Network
client.cloud.networks.list(*, project_id, region_id, **params) -> SyncOffsetPage[Network]
client.cloud.networks.delete(network_id, *, project_id, region_id) -> TaskIDList
client.cloud.networks.get(network_id, *, project_id, region_id) -> Network

Subnets

Methods:

client.cloud.networks.subnets.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.networks.subnets.update(subnet_id, *, project_id, region_id, **params) -> Subnet
client.cloud.networks.subnets.list(*, project_id, region_id, **params) -> SyncOffsetPage[Subnet]
client.cloud.networks.subnets.delete(subnet_id, *, project_id, region_id) -> TaskIDList
client.cloud.networks.subnets.get(subnet_id, *, project_id, region_id) -> Subnet

Routers

Types:

from gcore.types.cloud.networks import Router, RouterList, SubnetID

Methods:

client.cloud.networks.routers.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.networks.routers.update(router_id, *, project_id, region_id, **params) -> Router
client.cloud.networks.routers.list(*, project_id, region_id, **params) -> SyncOffsetPage[Router]
client.cloud.networks.routers.delete(router_id, *, project_id, region_id) -> TaskIDList
client.cloud.networks.routers.attach_subnet(router_id, *, project_id, region_id, **params) -> Router
client.cloud.networks.routers.detach_subnet(router_id, *, project_id, region_id, **params) -> Router
client.cloud.networks.routers.get(router_id, *, project_id, region_id) -> Router

Volumes

Types:

from gcore.types.cloud import Volume

Methods:

client.cloud.volumes.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.volumes.update(volume_id, *, project_id, region_id, **params) -> Volume
client.cloud.volumes.list(*, project_id, region_id, **params) -> SyncOffsetPage[Volume]
client.cloud.volumes.delete(volume_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.volumes.attach_to_instance(volume_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.volumes.change_type(volume_id, *, project_id, region_id, **params) -> Volume
client.cloud.volumes.detach_from_instance(volume_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.volumes.get(volume_id, *, project_id, region_id) -> Volume
client.cloud.volumes.resize(volume_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.volumes.revert_to_last_snapshot(volume_id, *, project_id, region_id) -> None

FloatingIPs

Types:

from gcore.types.cloud import FloatingIPDetailed

Methods:

client.cloud.floating_ips.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.floating_ips.update(floating_ip_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.floating_ips.list(*, project_id, region_id, **params) -> SyncOffsetPage[FloatingIPDetailed]
client.cloud.floating_ips.delete(floating_ip_id, *, project_id, region_id) -> TaskIDList
client.cloud.floating_ips.assign(floating_ip_id, *, project_id, region_id, **params) -> FloatingIP
client.cloud.floating_ips.get(floating_ip_id, *, project_id, region_id) -> FloatingIP
client.cloud.floating_ips.unassign(floating_ip_id, *, project_id, region_id) -> FloatingIP

SecurityGroups

Types:

from gcore.types.cloud import SecurityGroup, SecurityGroupRule

Methods:

client.cloud.security_groups.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.security_groups.update(group_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.security_groups.list(*, project_id, region_id, **params) -> SyncOffsetPage[SecurityGroup]
client.cloud.security_groups.delete(group_id, *, project_id, region_id) -> None
client.cloud.security_groups.copy(group_id, *, project_id, region_id, **params) -> SecurityGroup
client.cloud.security_groups.get(group_id, *, project_id, region_id) -> SecurityGroup
client.cloud.security_groups.revert_to_default(group_id, *, project_id, region_id) -> SecurityGroup

Rules

Methods:

client.cloud.security_groups.rules.create(group_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.security_groups.rules.delete(rule_id, *, project_id, region_id, group_id) -> TaskIDList
client.cloud.security_groups.rules.replace(rule_id, *, project_id, region_id, **params) -> SecurityGroupRule

Users

RoleAssignments

Types:

from gcore.types.cloud.users import RoleAssignment, RoleAssignmentUpdatedDeleted

Methods:

client.cloud.users.role_assignments.create(**params) -> RoleAssignment
client.cloud.users.role_assignments.update(assignment_id, **params) -> RoleAssignmentUpdatedDeleted
client.cloud.users.role_assignments.list(**params) -> SyncOffsetPage[RoleAssignment]
client.cloud.users.role_assignments.delete(assignment_id) -> RoleAssignmentUpdatedDeleted

Inference

Types:

from gcore.types.cloud import InferenceRegionCapacity, InferenceRegionCapacityList

Methods:

client.cloud.inference.get_capacity_by_region() -> InferenceRegionCapacityList

Flavors

Types:

from gcore.types.cloud.inference import InferenceFlavor

Methods:

client.cloud.inference.flavors.list(**params) -> SyncOffsetPage[InferenceFlavor]
client.cloud.inference.flavors.get(flavor_name) -> InferenceFlavor

Deployments

Types:

from gcore.types.cloud.inference import (
    InferenceDeployment,
    InferenceDeploymentAPIKey,
    Probe,
    ProbeConfig,
    ProbeExec,
    ProbeHTTPGet,
    ProbeTcpSocket,
)

Methods:

client.cloud.inference.deployments.create(*, project_id, **params) -> TaskIDList
client.cloud.inference.deployments.update(deployment_name, *, project_id, **params) -> TaskIDList
client.cloud.inference.deployments.list(*, project_id, **params) -> SyncOffsetPage[InferenceDeployment]
client.cloud.inference.deployments.delete(deployment_name, *, project_id) -> TaskIDList
client.cloud.inference.deployments.get(deployment_name, *, project_id) -> InferenceDeployment
client.cloud.inference.deployments.get_api_key(deployment_name, *, project_id) -> InferenceDeploymentAPIKey
client.cloud.inference.deployments.start(deployment_name, *, project_id) -> None
client.cloud.inference.deployments.stop(deployment_name, *, project_id) -> None

Logs

Types:

from gcore.types.cloud.inference.deployments import InferenceDeploymentLog

Methods:

client.cloud.inference.deployments.logs.list(deployment_name, *, project_id, **params) -> SyncOffsetPage[InferenceDeploymentLog]

RegistryCredentials

Types:

from gcore.types.cloud.inference import InferenceRegistryCredentials

Methods:

client.cloud.inference.registry_credentials.create(*, project_id, **params) -> InferenceRegistryCredentials
client.cloud.inference.registry_credentials.list(*, project_id, **params) -> SyncOffsetPage[InferenceRegistryCredentials]
client.cloud.inference.registry_credentials.delete(credential_name, *, project_id) -> None
client.cloud.inference.registry_credentials.get(credential_name, *, project_id) -> InferenceRegistryCredentials
client.cloud.inference.registry_credentials.replace(credential_name, *, project_id, **params) -> InferenceRegistryCredentials

Secrets

Types:

from gcore.types.cloud.inference import InferenceSecret

Methods:

client.cloud.inference.secrets.create(*, project_id, **params) -> InferenceSecret
client.cloud.inference.secrets.list(*, project_id, **params) -> SyncOffsetPage[InferenceSecret]
client.cloud.inference.secrets.delete(secret_name, *, project_id) -> None
client.cloud.inference.secrets.get(secret_name, *, project_id) -> InferenceSecret
client.cloud.inference.secrets.replace(secret_name, *, project_id, **params) -> InferenceSecret

APIKeys

Types:

from gcore.types.cloud.inference import InferenceAPIKey, InferenceAPIKeyCreated

Methods:

client.cloud.inference.api_keys.create(*, project_id, **params) -> InferenceAPIKeyCreated
client.cloud.inference.api_keys.update(api_key_name, *, project_id, **params) -> InferenceAPIKey
client.cloud.inference.api_keys.list(*, project_id, **params) -> SyncOffsetPage[InferenceAPIKey]
client.cloud.inference.api_keys.delete(api_key_name, *, project_id) -> None
client.cloud.inference.api_keys.get(api_key_name, *, project_id) -> InferenceAPIKey

Applications

Deployments

Types:

from gcore.types.cloud.inference.applications import (
    InferenceApplicationDeployment,
    InferenceApplicationDeploymentList,
)

Methods:

client.cloud.inference.applications.deployments.create(*, project_id, **params) -> TaskIDList
client.cloud.inference.applications.deployments.update(deployment_name, *, project_id, **params) -> TaskIDList
client.cloud.inference.applications.deployments.list(*, project_id) -> InferenceApplicationDeploymentList
client.cloud.inference.applications.deployments.delete(deployment_name, *, project_id) -> TaskIDList
client.cloud.inference.applications.deployments.get(deployment_name, *, project_id) -> InferenceApplicationDeployment

Templates

Types:

from gcore.types.cloud.inference.applications import (
    InferenceApplicationTemplate,
    InferenceApplicationTemplateList,
)

Methods:

client.cloud.inference.applications.templates.list() -> InferenceApplicationTemplateList
client.cloud.inference.applications.templates.get(application_name) -> InferenceApplicationTemplate

PlacementGroups

Types:

from gcore.types.cloud import PlacementGroup, PlacementGroupList

Methods:

client.cloud.placement_groups.create(*, project_id, region_id, **params) -> PlacementGroup
client.cloud.placement_groups.list(*, project_id, region_id) -> PlacementGroupList
client.cloud.placement_groups.delete(group_id, *, project_id, region_id) -> TaskIDList
client.cloud.placement_groups.get(group_id, *, project_id, region_id) -> PlacementGroup

Baremetal

Images

Methods:

client.cloud.baremetal.images.list(*, project_id, region_id, **params) -> ImageList

Flavors

Methods:

client.cloud.baremetal.flavors.list(*, project_id, region_id, **params) -> BaremetalFlavorList

Servers

Types:

from gcore.types.cloud.baremetal import (
    BaremetalFixedAddress,
    BaremetalFloatingAddress,
    BaremetalServer,
)

Methods:

client.cloud.baremetal.servers.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.baremetal.servers.list(*, project_id, region_id, **params) -> SyncOffsetPage[BaremetalServer]
client.cloud.baremetal.servers.rebuild(server_id, *, project_id, region_id, **params) -> TaskIDList

Registries

Types:

from gcore.types.cloud import Registry, RegistryList, RegistryTag

Methods:

client.cloud.registries.create(*, project_id, region_id, **params) -> Registry
client.cloud.registries.list(*, project_id, region_id) -> RegistryList
client.cloud.registries.delete(registry_id, *, project_id, region_id) -> None
client.cloud.registries.get(registry_id, *, project_id, region_id) -> Registry
client.cloud.registries.resize(registry_id, *, project_id, region_id, **params) -> Registry

Repositories

Types:

from gcore.types.cloud.registries import RegistryRepository, RegistryRepositoryList

Methods:

client.cloud.registries.repositories.list(registry_id, *, project_id, region_id) -> RegistryRepositoryList
client.cloud.registries.repositories.delete(repository_name, *, project_id, region_id, registry_id) -> None

Artifacts

Types:

from gcore.types.cloud.registries import RegistryArtifact, RegistryArtifactList

Methods:

client.cloud.registries.artifacts.list(repository_name, *, project_id, region_id, registry_id) -> RegistryArtifactList
client.cloud.registries.artifacts.delete(digest, *, project_id, region_id, registry_id, repository_name) -> None

Users

Types:

from gcore.types.cloud.registries import (
    RegistryUser,
    RegistryUserCreated,
    RegistryUserList,
    UserRefreshSecretResponse,
)

Methods:

client.cloud.registries.users.create(registry_id, *, project_id, region_id, **params) -> RegistryUserCreated
client.cloud.registries.users.update(user_id, *, project_id, region_id, registry_id, **params) -> RegistryUser
client.cloud.registries.users.list(registry_id, *, project_id, region_id) -> RegistryUserList
client.cloud.registries.users.delete(user_id, *, project_id, region_id, registry_id) -> None
client.cloud.registries.users.create_multiple(registry_id, *, project_id, region_id, **params) -> RegistryUserCreated
client.cloud.registries.users.refresh_secret(user_id, *, project_id, region_id, registry_id) -> UserRefreshSecretResponse

FileShares

Types:

from gcore.types.cloud import FileShare

Methods:

client.cloud.file_shares.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.file_shares.update(file_share_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.file_shares.list(*, project_id, region_id, **params) -> SyncOffsetPage[FileShare]
client.cloud.file_shares.delete(file_share_id, *, project_id, region_id) -> TaskIDList
client.cloud.file_shares.get(file_share_id, *, project_id, region_id) -> FileShare
client.cloud.file_shares.resize(file_share_id, *, project_id, region_id, **params) -> TaskIDList

AccessRules

Types:

from gcore.types.cloud.file_shares import AccessRule, AccessRuleList

Methods:

client.cloud.file_shares.access_rules.create(file_share_id, *, project_id, region_id, **params) -> AccessRule
client.cloud.file_shares.access_rules.list(file_share_id, *, project_id, region_id) -> AccessRuleList
client.cloud.file_shares.access_rules.delete(access_rule_id, *, project_id, region_id, file_share_id) -> None

BillingReservations

Types:

from gcore.types.cloud import BillingReservation, BillingReservations

Methods:

client.cloud.billing_reservations.list(**params) -> BillingReservations

GPUBaremetal

Clusters

Types:

from gcore.types.cloud.gpu_baremetal import GPUBaremetalCluster

Methods:

client.cloud.gpu_baremetal.clusters.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_baremetal.clusters.list(*, project_id, region_id, **params) -> SyncOffsetPage[GPUBaremetalCluster]
client.cloud.gpu_baremetal.clusters.delete(cluster_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_baremetal.clusters.action(cluster_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_baremetal.clusters.get(cluster_id, *, project_id, region_id) -> GPUBaremetalCluster
client.cloud.gpu_baremetal.clusters.powercycle_all_servers(cluster_id, *, project_id, region_id) -> GPUBaremetalClusterServerV1List
client.cloud.gpu_baremetal.clusters.reboot_all_servers(cluster_id, *, project_id, region_id) -> GPUBaremetalClusterServerV1List
client.cloud.gpu_baremetal.clusters.rebuild(cluster_id, *, project_id, region_id) -> TaskIDList
client.cloud.gpu_baremetal.clusters.resize(cluster_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_baremetal.clusters.update_servers_settings(cluster_id, *, project_id, region_id, **params) -> GPUBaremetalCluster

Interfaces

Methods:

client.cloud.gpu_baremetal.clusters.interfaces.list(cluster_id, *, project_id, region_id) -> NetworkInterfaceList
client.cloud.gpu_baremetal.clusters.interfaces.attach(instance_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_baremetal.clusters.interfaces.detach(instance_id, *, project_id, region_id, **params) -> TaskIDList

Servers

Types:

from gcore.types.cloud.gpu_baremetal.clusters import (
    GPUBaremetalClusterServer,
    GPUBaremetalClusterServerV1,
    GPUBaremetalClusterServerV1List,
)

Methods:

client.cloud.gpu_baremetal.clusters.servers.list(cluster_id, *, project_id, region_id, **params) -> SyncOffsetPage[GPUBaremetalClusterServer]
client.cloud.gpu_baremetal.clusters.servers.delete(instance_id, *, project_id, region_id, cluster_id, **params) -> TaskIDList
client.cloud.gpu_baremetal.clusters.servers.get_console(instance_id, *, project_id, region_id) -> Console
client.cloud.gpu_baremetal.clusters.servers.powercycle(instance_id, *, project_id, region_id) -> GPUBaremetalClusterServerV1
client.cloud.gpu_baremetal.clusters.servers.reboot(instance_id, *, project_id, region_id) -> GPUBaremetalClusterServerV1
client.cloud.gpu_baremetal.clusters.servers.rebuild(server_id, *, project_id, region_id, cluster_id) -> TaskIDList

Flavors

Types:

from gcore.types.cloud.gpu_baremetal.clusters import GPUBaremetalFlavor, GPUBaremetalFlavorList

Methods:

client.cloud.gpu_baremetal.clusters.flavors.list(*, project_id, region_id, **params) -> GPUBaremetalFlavorList

Images

Methods:

client.cloud.gpu_baremetal.clusters.images.list(*, project_id, region_id) -> GPUImageList
client.cloud.gpu_baremetal.clusters.images.delete(image_id, *, project_id, region_id) -> TaskIDList
client.cloud.gpu_baremetal.clusters.images.get(image_id, *, project_id, region_id) -> GPUImage
client.cloud.gpu_baremetal.clusters.images.upload(*, project_id, region_id, **params) -> TaskIDList

GPUVirtual

Clusters

Types:

from gcore.types.cloud.gpu_virtual import GPUVirtualCluster

Methods:

client.cloud.gpu_virtual.clusters.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_virtual.clusters.update(cluster_id, *, project_id, region_id, **params) -> GPUVirtualCluster
client.cloud.gpu_virtual.clusters.list(*, project_id, region_id, **params) -> SyncOffsetPage[GPUVirtualCluster]
client.cloud.gpu_virtual.clusters.delete(cluster_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_virtual.clusters.action(cluster_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.gpu_virtual.clusters.get(cluster_id, *, project_id, region_id) -> GPUVirtualCluster

Servers

Types:

from gcore.types.cloud.gpu_virtual.clusters import (
    GPUVirtualClusterServer,
    GPUVirtualClusterServerList,
)

Methods:

client.cloud.gpu_virtual.clusters.servers.list(cluster_id, *, project_id, region_id, **params) -> GPUVirtualClusterServerList
client.cloud.gpu_virtual.clusters.servers.delete(server_id, *, project_id, region_id, cluster_id, **params) -> TaskIDList

Volumes

Types:

from gcore.types.cloud.gpu_virtual.clusters import (
    GPUVirtualClusterVolume,
    GPUVirtualClusterVolumeList,
)

Methods:

client.cloud.gpu_virtual.clusters.volumes.list(cluster_id, *, project_id, region_id) -> GPUVirtualClusterVolumeList

Interfaces

Types:

from gcore.types.cloud.gpu_virtual.clusters import GPUVirtualInterface, GPUVirtualInterfaceList

Methods:

client.cloud.gpu_virtual.clusters.interfaces.list(cluster_id, *, project_id, region_id) -> GPUVirtualInterfaceList

Flavors

Types:

from gcore.types.cloud.gpu_virtual.clusters import GPUVirtualFlavor, GPUVirtualFlavorList

Methods:

client.cloud.gpu_virtual.clusters.flavors.list(*, project_id, region_id, **params) -> GPUVirtualFlavorList

Images

Methods:

client.cloud.gpu_virtual.clusters.images.list(*, project_id, region_id) -> GPUImageList
client.cloud.gpu_virtual.clusters.images.delete(image_id, *, project_id, region_id) -> TaskIDList
client.cloud.gpu_virtual.clusters.images.get(image_id, *, project_id, region_id) -> GPUImage
client.cloud.gpu_virtual.clusters.images.upload(*, project_id, region_id, **params) -> TaskIDList

Instances

Types:

from gcore.types.cloud import InstanceInterface

Methods:

client.cloud.instances.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.update(instance_id, *, project_id, region_id, **params) -> Instance
client.cloud.instances.list(*, project_id, region_id, **params) -> SyncOffsetPage[Instance]
client.cloud.instances.delete(instance_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.action(instance_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.add_to_placement_group(instance_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.assign_security_group(instance_id, *, project_id, region_id, **params) -> None
client.cloud.instances.disable_port_security(port_id, *, project_id, region_id) -> InstanceInterface
client.cloud.instances.enable_port_security(port_id, *, project_id, region_id) -> InstanceInterface
client.cloud.instances.get(instance_id, *, project_id, region_id) -> Instance
client.cloud.instances.get_console(instance_id, *, project_id, region_id, **params) -> Console
client.cloud.instances.remove_from_placement_group(instance_id, *, project_id, region_id) -> TaskIDList
client.cloud.instances.resize(instance_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.unassign_security_group(instance_id, *, project_id, region_id, **params) -> None

Flavors

Types:

from gcore.types.cloud.instances import InstanceFlavorDetailed, InstanceFlavorList

Methods:

client.cloud.instances.flavors.list(*, project_id, region_id, **params) -> InstanceFlavorList

Interfaces

Methods:

client.cloud.instances.interfaces.list(instance_id, *, project_id, region_id) -> NetworkInterfaceList
client.cloud.instances.interfaces.attach(instance_id, *, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.interfaces.detach(instance_id, *, project_id, region_id, **params) -> TaskIDList

Images

Methods:

client.cloud.instances.images.update(image_id, *, project_id, region_id, **params) -> Image
client.cloud.instances.images.list(*, project_id, region_id, **params) -> ImageList
client.cloud.instances.images.delete(image_id, *, project_id, region_id) -> TaskIDList
client.cloud.instances.images.create_from_volume(*, project_id, region_id, **params) -> TaskIDList
client.cloud.instances.images.get(image_id, *, project_id, region_id, **params) -> Image
client.cloud.instances.images.upload(*, project_id, region_id, **params) -> TaskIDList

Metrics

Types:

from gcore.types.cloud.instances import Metrics, MetricsList

Methods:

client.cloud.instances.metrics.list(instance_id, *, project_id, region_id, **params) -> MetricsList

K8S

Types:

from gcore.types.cloud import K8SClusterVersion, K8SClusterVersionList

Methods:

client.cloud.k8s.list_versions(*, project_id, region_id) -> K8SClusterVersionList

Flavors

Methods:

client.cloud.k8s.flavors.list(*, project_id, region_id, **params) -> BaremetalFlavorList

Clusters

Types:

from gcore.types.cloud.k8s import (
    K8SCluster,
    K8SClusterCertificate,
    K8SClusterKubeconfig,
    K8SClusterList,
)

Methods:

client.cloud.k8s.clusters.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.k8s.clusters.update(cluster_name, *, project_id, region_id, **params) -> TaskIDList
client.cloud.k8s.clusters.list(*, project_id, region_id) -> K8SClusterList
client.cloud.k8s.clusters.delete(cluster_name, *, project_id, region_id, **params) -> TaskIDList
client.cloud.k8s.clusters.get(cluster_name, *, project_id, region_id) -> K8SCluster
client.cloud.k8s.clusters.get_certificate(cluster_name, *, project_id, region_id) -> K8SClusterCertificate
client.cloud.k8s.clusters.get_kubeconfig(cluster_name, *, project_id, region_id) -> K8SClusterKubeconfig
client.cloud.k8s.clusters.list_versions_for_upgrade(cluster_name, *, project_id, region_id) -> K8SClusterVersionList
client.cloud.k8s.clusters.upgrade(cluster_name, *, project_id, region_id, **params) -> TaskIDList

Nodes

Methods:

client.cloud.k8s.clusters.nodes.list(cluster_name, *, project_id, region_id, **params) -> InstanceList
client.cloud.k8s.clusters.nodes.delete(instance_id, *, project_id, region_id, cluster_name) -> None

Pools

Types:

from gcore.types.cloud.k8s.clusters import K8SClusterPool, K8SClusterPoolList, K8SClusterPoolQuota

Methods:

client.cloud.k8s.clusters.pools.create(cluster_name, *, project_id, region_id, **params) -> TaskIDList
client.cloud.k8s.clusters.pools.update(pool_name, *, project_id, region_id, cluster_name, **params) -> K8SClusterPool
client.cloud.k8s.clusters.pools.list(cluster_name, *, project_id, region_id) -> K8SClusterPoolList
client.cloud.k8s.clusters.pools.delete(pool_name, *, project_id, region_id, cluster_name) -> TaskIDList
client.cloud.k8s.clusters.pools.check_quota(*, project_id, region_id, **params) -> K8SClusterPoolQuota
client.cloud.k8s.clusters.pools.get(pool_name, *, project_id, region_id, cluster_name) -> K8SClusterPool
client.cloud.k8s.clusters.pools.resize(pool_name, *, project_id, region_id, cluster_name, **params) -> TaskIDList

Nodes

Methods:

client.cloud.k8s.clusters.pools.nodes.list(pool_name, *, project_id, region_id, cluster_name, **params) -> InstanceList
client.cloud.k8s.clusters.pools.nodes.delete(instance_id, *, project_id, region_id, cluster_name, pool_name) -> None

AuditLogs

Types:

from gcore.types.cloud import AuditLogEntry

Methods:

client.cloud.audit_logs.list(**params) -> SyncOffsetPage[AuditLogEntry]

CostReports

Types:

from gcore.types.cloud import CostReportAggregated, CostReportAggregatedMonthly, CostReportDetailed

Methods:

client.cloud.cost_reports.get_aggregated(**params) -> CostReportAggregated
client.cloud.cost_reports.get_aggregated_monthly(**params) -> CostReportAggregatedMonthly
client.cloud.cost_reports.get_detailed(**params) -> CostReportDetailed

UsageReports

Types:

from gcore.types.cloud import UsageReport

Methods:

client.cloud.usage_reports.get(**params) -> UsageReport

Databases

Postgres

Clusters

Types:

from gcore.types.cloud.databases.postgres import PostgresCluster, PostgresClusterShort

Methods:

client.cloud.databases.postgres.clusters.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.databases.postgres.clusters.update(cluster_name, *, project_id, region_id, **params) -> TaskIDList
client.cloud.databases.postgres.clusters.list(*, project_id, region_id, **params) -> SyncOffsetPage[PostgresClusterShort]
client.cloud.databases.postgres.clusters.delete(cluster_name, *, project_id, region_id) -> TaskIDList
client.cloud.databases.postgres.clusters.get(cluster_name, *, project_id, region_id) -> PostgresCluster

UserCredentials

Types:

from gcore.types.cloud.databases.postgres.clusters import PostgresUserCredentials

Methods:

client.cloud.databases.postgres.clusters.user_credentials.get(username, *, project_id, region_id, cluster_name) -> PostgresUserCredentials
client.cloud.databases.postgres.clusters.user_credentials.regenerate(username, *, project_id, region_id, cluster_name) -> PostgresUserCredentials

Configurations

Types:

from gcore.types.cloud.databases.postgres import PostgresConfiguration

Methods:

client.cloud.databases.postgres.configurations.get(*, project_id, region_id) -> PostgresConfiguration

CustomConfigurations

Types:

from gcore.types.cloud.databases.postgres import PgConfValidation

Methods:

client.cloud.databases.postgres.custom_configurations.validate(*, project_id, region_id, **params) -> PgConfValidation

VolumeSnapshots

Types:

from gcore.types.cloud import Snapshot

Methods:

client.cloud.volume_snapshots.create(*, project_id, region_id, **params) -> TaskIDList
client.cloud.volume_snapshots.update(snapshot_id, *, project_id, region_id, **params) -> Snapshot
client.cloud.volume_snapshots.delete(snapshot_id, *, project_id, region_id) -> TaskIDList
client.cloud.volume_snapshots.get(snapshot_id, *, project_id, region_id) -> Snapshot

FilesExpand file tree

api.md

Latest commit

History

api.md

File metadata and controls

Cloud

Projects

Tasks

Regions

Quotas

Requests

Secrets

SSHKeys

IPRanges

LoadBalancers

L7Policies

Rules

Flavors

Listeners

Pools

HealthMonitors

Members

Metrics

Statuses

ReservedFixedIPs

Vip

CandidatePorts

ConnectedPorts

Networks

Subnets

Routers

Volumes

FloatingIPs

SecurityGroups

Rules

Users

RoleAssignments

Inference

Flavors

Deployments

Logs

RegistryCredentials

Secrets

APIKeys

Applications

Deployments

Templates

PlacementGroups

Baremetal

Images

Flavors

Servers

Registries

Repositories

Artifacts

Tags

Users

FileShares

AccessRules

BillingReservations

GPUBaremetal

Clusters

Interfaces

Servers

Flavors

Images

GPUVirtual

Clusters

Servers

Volumes

Interfaces

Flavors

Images

Instances

Flavors

Interfaces

Images

Metrics

K8S