armredhatopenshift

package module

v2.0.0 Latest Latest Go to latest Published: Jan 29, 2026 License: MIT Imports: 14 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/Azure/azure-sdk-for-go

Links

Open Source Insights

README ¶

Azure RedHat Open Shift Module for Go

The armredhatopenshift module provides operations for working with Azure RedHat Open Shift.

Source code

Getting started

Prerequisites

an Azure subscription
Supported version of Go (You could download and install the latest version of Go from here. It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, you could refer this doc.)

Install the package

This project uses Go modules for versioning and dependency management.

Install the Azure RedHat Open Shift module:

go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2

Authorization

When creating a client, you will need to provide a credential for authenticating with Azure RedHat Open Shift. The azidentity module provides facilities for various ways of authenticating with Azure including client/secret, certificate, managed identity, and more.

cred, err := azidentity.NewDefaultAzureCredential(nil)

For more information on authentication, please see the documentation for azidentity at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azidentity.

Client Factory

Azure RedHat Open Shift module consists of one or more clients. We provide a client factory which could be used to create any client in this module.

clientFactory, err := armredhatopenshift.NewClientFactory(, cred, nil)

You can use ClientOptions in package github.com/Azure/azure-sdk-for-go/sdk/azcore/arm to set endpoint to connect with public and sovereign clouds as well as Azure Stack. For more information, please see the documentation for azcore at pkg.go.dev/github.com/Azure/azure-sdk-for-go/sdk/azcore.

options := arm.ClientOptions {
    ClientOptions: azcore.ClientOptions {
        Cloud: cloud.AzureChina,
    },
}
clientFactory, err := armredhatopenshift.NewClientFactory(, cred, &options)

Clients

A client groups a set of related APIs, providing access to its functionality. Create one or more clients to access the APIs you require using client factory.

client := clientFactory.NewOpenShiftClustersClient()

Fakes

The fake package contains types used for constructing in-memory fake servers used in unit tests. This allows writing tests to cover various success/error conditions without the need for connecting to a live service.

Please see https://github.com/Azure/azure-sdk-for-go/tree/main/sdk/samples/fakes for details and examples on how to use fakes.

Provide Feedback

If you encounter bugs or have suggestions, please open an issue and assign the RedHat Open Shift label.

Contributing

This project welcomes contributions and suggestions. Most contributions require you to agree to a Contributor License Agreement (CLA) declaring that you have the right to, and actually do, grant us the rights to use your contribution. For details, visit https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the instructions provided by the bot. You will only need to do this once across all repos using our CLA.

This project has adopted the Microsoft Open Source Code of Conduct. For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.

Documentation ¶

Index ¶

Examples ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type APIServerProfile ¶

type APIServerProfile struct {
	// API server visibility.
	Visibility *Visibility

	// READ-ONLY; The IP of the cluster API server.
	IP *string

	// READ-ONLY; The URL to access the cluster API server.
	URL *string
}

APIServerProfile represents an API server profile.

func (APIServerProfile) MarshalJSON ¶

func (a APIServerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type APIServerProfile.

func (*APIServerProfile) UnmarshalJSON ¶

func (a *APIServerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type APIServerProfile.

type ClientFactory ¶

type ClientFactory struct {
	// contains filtered or unexported fields
}

ClientFactory is a client factory used to create any client in this module. Don't use this type directly, use NewClientFactory instead.

func NewClientFactory ¶

func NewClientFactory(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*ClientFactory, error)

NewClientFactory creates a new instance of ClientFactory with the specified values. The parameter values will be propagated to any client created from this factory.

subscriptionID - The ID of the target subscription. The value must be an UUID.
credential - used to authorize requests. Usually a credential from azidentity.
options - pass nil to accept the default values.

func (*ClientFactory) NewOpenShiftClustersClient ¶

func (c *ClientFactory) NewOpenShiftClustersClient() *OpenShiftClustersClient

NewOpenShiftClustersClient creates a new instance of OpenShiftClustersClient.

func (*ClientFactory) NewOpenShiftVersionsClient ¶

func (c *ClientFactory) NewOpenShiftVersionsClient() *OpenShiftVersionsClient

NewOpenShiftVersionsClient creates a new instance of OpenShiftVersionsClient.

func (*ClientFactory) NewOperationsClient ¶

func (c *ClientFactory) NewOperationsClient() *OperationsClient

NewOperationsClient creates a new instance of OperationsClient.

func (*ClientFactory) NewPlatformWorkloadIdentityRoleSetClient ¶

func (c *ClientFactory) NewPlatformWorkloadIdentityRoleSetClient() *PlatformWorkloadIdentityRoleSetClient

NewPlatformWorkloadIdentityRoleSetClient creates a new instance of PlatformWorkloadIdentityRoleSetClient.

func (*ClientFactory) NewPlatformWorkloadIdentityRoleSetsClient ¶

func (c *ClientFactory) NewPlatformWorkloadIdentityRoleSetsClient() *PlatformWorkloadIdentityRoleSetsClient

NewPlatformWorkloadIdentityRoleSetsClient creates a new instance of PlatformWorkloadIdentityRoleSetsClient.

type ClusterProfile ¶

type ClusterProfile struct {
	// The domain for the cluster.
	Domain *string

	// If FIPS validated crypto modules are used
	FipsValidatedModules *FipsValidatedModules

	// The pull secret for the cluster.
	PullSecret *string

	// The ID of the cluster resource group.
	ResourceGroupID *string

	// The version of the cluster.
	Version *string

	// READ-ONLY; The URL of the managed OIDC issuer in a workload identity cluster.
	OidcIssuer *string
}

ClusterProfile represents a cluster profile.

func (ClusterProfile) MarshalJSON ¶

func (c ClusterProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ClusterProfile.

func (*ClusterProfile) UnmarshalJSON ¶

func (c *ClusterProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ClusterProfile.

type ConsoleProfile ¶

type ConsoleProfile struct {
	// READ-ONLY; The URL to access the cluster console.
	URL *string
}

ConsoleProfile represents a console profile.

func (ConsoleProfile) MarshalJSON ¶

func (c ConsoleProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ConsoleProfile.

func (*ConsoleProfile) UnmarshalJSON ¶

func (c *ConsoleProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ConsoleProfile.

type CreatedByType ¶

type CreatedByType string

CreatedByType - The type of identity that created the resource.

const (
	CreatedByTypeApplication     CreatedByType = "Application"
	CreatedByTypeKey             CreatedByType = "Key"
	CreatedByTypeManagedIdentity CreatedByType = "ManagedIdentity"
	CreatedByTypeUser            CreatedByType = "User"
)

func PossibleCreatedByTypeValues ¶

func PossibleCreatedByTypeValues() []CreatedByType

PossibleCreatedByTypeValues returns the possible values for the CreatedByType const type.

type Display ¶

type Display struct {
	// Friendly name of the operation.
	Description *string

	// Operation type: read, write, delete, listKeys/action, etc.
	Operation *string

	// Friendly name of the resource provider.
	Provider *string

	// Resource type on which the operation is performed.
	Resource *string
}

Display represents the display details of an operation.

func (Display) MarshalJSON ¶

func (d Display) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Display.

func (*Display) UnmarshalJSON ¶

func (d *Display) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Display.

type EffectiveOutboundIP ¶

type EffectiveOutboundIP struct {
	// The fully qualified Azure resource id of an IP address resource.
	ID *string
}

EffectiveOutboundIP represents an effective outbound IP resource of the cluster public load balancer.

func (EffectiveOutboundIP) MarshalJSON ¶

func (e EffectiveOutboundIP) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type EffectiveOutboundIP.

func (*EffectiveOutboundIP) UnmarshalJSON ¶

func (e *EffectiveOutboundIP) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type EffectiveOutboundIP.

type EncryptionAtHost ¶

type EncryptionAtHost string

EncryptionAtHost - EncryptionAtHost represents encryption at host state

const (
	EncryptionAtHostDisabled EncryptionAtHost = "Disabled"
	EncryptionAtHostEnabled  EncryptionAtHost = "Enabled"
)

func PossibleEncryptionAtHostValues ¶

func PossibleEncryptionAtHostValues() []EncryptionAtHost

PossibleEncryptionAtHostValues returns the possible values for the EncryptionAtHost const type.

type FipsValidatedModules ¶

type FipsValidatedModules string

FipsValidatedModules - FipsValidatedModules determines if FIPS is used.

const (
	FipsValidatedModulesDisabled FipsValidatedModules = "Disabled"
	FipsValidatedModulesEnabled  FipsValidatedModules = "Enabled"
)

func PossibleFipsValidatedModulesValues ¶

func PossibleFipsValidatedModulesValues() []FipsValidatedModules

PossibleFipsValidatedModulesValues returns the possible values for the FipsValidatedModules const type.

type IngressProfile ¶

type IngressProfile struct {
	// The ingress profile name.
	Name *string

	// Ingress visibility.
	Visibility *Visibility

	// READ-ONLY; The IP of the ingress.
	IP *string
}

IngressProfile represents an ingress profile.

func (IngressProfile) MarshalJSON ¶

func (i IngressProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type IngressProfile.

func (*IngressProfile) UnmarshalJSON ¶

func (i *IngressProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type IngressProfile.

type LoadBalancerProfile ¶

type LoadBalancerProfile struct {
	// The desired managed outbound IPs for the cluster public load balancer.
	ManagedOutboundIPs *ManagedOutboundIPs

	// READ-ONLY; The list of effective outbound IP addresses of the public load balancer.
	EffectiveOutboundIPs []*EffectiveOutboundIP
}

LoadBalancerProfile represents the profile of the cluster public load balancer.

func (LoadBalancerProfile) MarshalJSON ¶

func (l LoadBalancerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type LoadBalancerProfile.

func (*LoadBalancerProfile) UnmarshalJSON ¶

func (l *LoadBalancerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type LoadBalancerProfile.

type ManagedOutboundIPs ¶

type ManagedOutboundIPs struct {
	// Count represents the desired number of IPv4 outbound IPs created and managed by Azure for the cluster public load balancer.
	// Allowed values are in the range of 1 - 20. The default value is 1.
	Count *int32
}

ManagedOutboundIPs represents the desired managed outbound IPs for the cluster public load balancer.

func (ManagedOutboundIPs) MarshalJSON ¶

func (m ManagedOutboundIPs) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedOutboundIPs.

func (*ManagedOutboundIPs) UnmarshalJSON ¶

func (m *ManagedOutboundIPs) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedOutboundIPs.

type ManagedServiceIdentity ¶

type ManagedServiceIdentity struct {
	// REQUIRED; Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).
	Type *ManagedServiceIdentityType

	// The set of user assigned identities associated with the resource. The userAssignedIdentities dictionary keys will be ARM
	// resource ids in the form:
	// '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}.
	// The dictionary values can be empty objects ({}) in
	// requests.
	UserAssignedIdentities map[string]*UserAssignedIdentity

	// READ-ONLY; The service principal ID of the system assigned identity. This property will only be provided for a system assigned
	// identity.
	PrincipalID *string

	// READ-ONLY; The tenant ID of the system assigned identity. This property will only be provided for a system assigned identity.
	TenantID *string
}

ManagedServiceIdentity - Managed service identity (system assigned and/or user assigned identities)

func (ManagedServiceIdentity) MarshalJSON ¶

func (m ManagedServiceIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ManagedServiceIdentity.

func (*ManagedServiceIdentity) UnmarshalJSON ¶

func (m *ManagedServiceIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ManagedServiceIdentity.

type ManagedServiceIdentityType ¶

type ManagedServiceIdentityType string

ManagedServiceIdentityType - Type of managed service identity (where both SystemAssigned and UserAssigned types are allowed).

const (
	ManagedServiceIdentityTypeNone                       ManagedServiceIdentityType = "None"
	ManagedServiceIdentityTypeSystemAssigned             ManagedServiceIdentityType = "SystemAssigned"
	ManagedServiceIdentityTypeSystemAssignedUserAssigned ManagedServiceIdentityType = "SystemAssigned,UserAssigned"
	ManagedServiceIdentityTypeUserAssigned               ManagedServiceIdentityType = "UserAssigned"
)

func PossibleManagedServiceIdentityTypeValues ¶

func PossibleManagedServiceIdentityTypeValues() []ManagedServiceIdentityType

PossibleManagedServiceIdentityTypeValues returns the possible values for the ManagedServiceIdentityType const type.

type MasterProfile ¶

type MasterProfile struct {
	// The resource ID of an associated DiskEncryptionSet, if applicable.
	DiskEncryptionSetID *string

	// Whether master virtual machines are encrypted at host.
	EncryptionAtHost *EncryptionAtHost

	// The Azure resource ID of the master subnet.
	SubnetID *string

	// The size of the master VMs.
	VMSize *string
}

MasterProfile represents a master profile.

func (MasterProfile) MarshalJSON ¶

func (m MasterProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type MasterProfile.

func (*MasterProfile) UnmarshalJSON ¶

func (m *MasterProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type MasterProfile.

type NetworkProfile ¶

type NetworkProfile struct {
	// The cluster load balancer profile.
	LoadBalancerProfile *LoadBalancerProfile

	// The OutboundType used for egress traffic.
	OutboundType *OutboundType

	// The CIDR used for OpenShift/Kubernetes Pods.
	PodCidr *string

	// Specifies whether subnets are pre-attached with an NSG
	PreconfiguredNSG *PreconfiguredNSG

	// The CIDR used for OpenShift/Kubernetes Services.
	ServiceCidr *string
}

NetworkProfile represents a network profile.

func (NetworkProfile) MarshalJSON ¶

func (n NetworkProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type NetworkProfile.

func (*NetworkProfile) UnmarshalJSON ¶

func (n *NetworkProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type NetworkProfile.

type OpenShiftCluster ¶

type OpenShiftCluster struct {
	// REQUIRED; The geo-location where the resource lives
	Location *string

	// Identity stores information about the cluster MSI(s) in a workload identity cluster.
	Identity *ManagedServiceIdentity

	// The cluster properties.
	Properties *OpenShiftClusterProperties

	// Resource tags.
	Tags map[string]*string

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

OpenShiftCluster represents an Azure Red Hat OpenShift cluster.

func (OpenShiftCluster) MarshalJSON ¶

func (o OpenShiftCluster) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftCluster.

func (*OpenShiftCluster) UnmarshalJSON ¶

func (o *OpenShiftCluster) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftCluster.

type OpenShiftClusterAdminKubeconfig ¶

type OpenShiftClusterAdminKubeconfig struct {
	// The base64-encoded kubeconfig file.
	Kubeconfig *string
}

OpenShiftClusterAdminKubeconfig represents an OpenShift cluster's admin kubeconfig.

func (OpenShiftClusterAdminKubeconfig) MarshalJSON ¶

func (o OpenShiftClusterAdminKubeconfig) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftClusterAdminKubeconfig.

func (*OpenShiftClusterAdminKubeconfig) UnmarshalJSON ¶

func (o *OpenShiftClusterAdminKubeconfig) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftClusterAdminKubeconfig.

type OpenShiftClusterCredentials ¶

type OpenShiftClusterCredentials struct {
	// The password for the kubeadmin user.
	KubeadminPassword *string

	// The username for the kubeadmin user.
	KubeadminUsername *string
}

OpenShiftClusterCredentials represents an OpenShift cluster's credentials.

func (OpenShiftClusterCredentials) MarshalJSON ¶

func (o OpenShiftClusterCredentials) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftClusterCredentials.

func (*OpenShiftClusterCredentials) UnmarshalJSON ¶

func (o *OpenShiftClusterCredentials) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftClusterCredentials.

type OpenShiftClusterList ¶

type OpenShiftClusterList struct {
	// The link used to get the next page of operations.
	NextLink *string

	// The list of OpenShift clusters.
	Value []*OpenShiftCluster
}

OpenShiftClusterList represents a list of OpenShift clusters.

func (OpenShiftClusterList) MarshalJSON ¶

func (o OpenShiftClusterList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftClusterList.

func (*OpenShiftClusterList) UnmarshalJSON ¶

func (o *OpenShiftClusterList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftClusterList.

type OpenShiftClusterProperties ¶

type OpenShiftClusterProperties struct {
	// The cluster API server profile.
	ApiserverProfile *APIServerProfile

	// The cluster profile.
	ClusterProfile *ClusterProfile

	// The console profile.
	ConsoleProfile *ConsoleProfile

	// The cluster ingress profiles.
	IngressProfiles []*IngressProfile

	// The cluster master profile.
	MasterProfile *MasterProfile

	// The cluster network profile.
	NetworkProfile *NetworkProfile

	// The workload identity profile.
	PlatformWorkloadIdentityProfile *PlatformWorkloadIdentityProfile

	// The cluster provisioning state.
	ProvisioningState *ProvisioningState

	// The cluster service principal profile.
	ServicePrincipalProfile *ServicePrincipalProfile

	// The cluster worker profiles.
	WorkerProfiles []*WorkerProfile

	// READ-ONLY; The cluster worker profiles status.
	WorkerProfilesStatus []*WorkerProfile
}

OpenShiftClusterProperties represents an OpenShift cluster's properties.

func (OpenShiftClusterProperties) MarshalJSON ¶

func (o OpenShiftClusterProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftClusterProperties.

func (*OpenShiftClusterProperties) UnmarshalJSON ¶

func (o *OpenShiftClusterProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftClusterProperties.

type OpenShiftClusterUpdate ¶

type OpenShiftClusterUpdate struct {
	// Identity stores information about the cluster MSI(s) in a workload identity cluster.
	Identity *ManagedServiceIdentity

	// The cluster properties.
	Properties *OpenShiftClusterProperties

	// The resource tags.
	Tags map[string]*string
}

OpenShiftClusterUpdate - OpenShiftCluster represents an Azure Red Hat OpenShift cluster.

func (OpenShiftClusterUpdate) MarshalJSON ¶

func (o OpenShiftClusterUpdate) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftClusterUpdate.

func (*OpenShiftClusterUpdate) UnmarshalJSON ¶

func (o *OpenShiftClusterUpdate) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftClusterUpdate.

type OpenShiftClustersClient ¶

type OpenShiftClustersClient struct {
	// contains filtered or unexported fields
}

OpenShiftClustersClient contains the methods for the OpenShiftClusters group. Don't use this type directly, use NewOpenShiftClustersClient() instead.

func NewOpenShiftClustersClient ¶

func NewOpenShiftClustersClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OpenShiftClustersClient, error)

NewOpenShiftClustersClient creates a new instance of OpenShiftClustersClient with the specified values.

subscriptionID - The ID of the target subscription. The value must be an UUID.
credential - used to authorize requests. Usually a credential from azidentity.
options - Contains optional client configuration. Pass nil to accept the default values.

func (*OpenShiftClustersClient) BeginCreateOrUpdate ¶

func (client *OpenShiftClustersClient) BeginCreateOrUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters OpenShiftCluster, options *OpenShiftClustersClientBeginCreateOrUpdateOptions) (*runtime.Poller[OpenShiftClustersClientCreateOrUpdateResponse], error)

BeginCreateOrUpdate - The operation returns properties of a OpenShift cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
resourceName - The name of the OpenShift cluster resource.
parameters - The OpenShift cluster resource.
options - OpenShiftClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the OpenShiftClustersClient.BeginCreateOrUpdate method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_CreateOrUpdate.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOpenShiftClustersClient().BeginCreateOrUpdate(ctx, "resourceGroup", "resourceName", armredhatopenshift.OpenShiftCluster{
		Location: to.Ptr("location"),
		Tags: map[string]*string{
			"key": to.Ptr("value"),
		},
		Identity: &armredhatopenshift.ManagedServiceIdentity{
			Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
				"": {},
			},
		},
		Properties: &armredhatopenshift.OpenShiftClusterProperties{
			ApiserverProfile: &armredhatopenshift.APIServerProfile{
				Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
			},
			ClusterProfile: &armredhatopenshift.ClusterProfile{
				Domain:               to.Ptr("cluster.location.aroapp.io"),
				FipsValidatedModules: to.Ptr(armredhatopenshift.FipsValidatedModulesEnabled),
				PullSecret:           to.Ptr("{\"auths\":{\"registry.connect.redhat.com\":{\"auth\":\"\"},\"registry.redhat.io\":{\"auth\":\"\"}}}"),
				ResourceGroupID:      to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
			},
			ConsoleProfile: &armredhatopenshift.ConsoleProfile{},
			IngressProfiles: []*armredhatopenshift.IngressProfile{
				{
					Name:       to.Ptr("default"),
					Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
				}},
			MasterProfile: &armredhatopenshift.MasterProfile{
				EncryptionAtHost: to.Ptr(armredhatopenshift.EncryptionAtHostEnabled),
				SubnetID:         to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
				VMSize:           to.Ptr("Standard_D8s_v3"),
			},
			NetworkProfile: &armredhatopenshift.NetworkProfile{
				LoadBalancerProfile: &armredhatopenshift.LoadBalancerProfile{
					ManagedOutboundIPs: &armredhatopenshift.ManagedOutboundIPs{
						Count: to.Ptr[int32](1),
					},
				},
				PodCidr:          to.Ptr("10.128.0.0/14"),
				PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
				ServiceCidr:      to.Ptr("172.30.0.0/16"),
			},
			PlatformWorkloadIdentityProfile: &armredhatopenshift.PlatformWorkloadIdentityProfile{
				PlatformWorkloadIdentities: map[string]*armredhatopenshift.PlatformWorkloadIdentity{
					"": {},
				},
			},
			ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
				ClientID:     to.Ptr("clientId"),
				ClientSecret: to.Ptr("clientSecret"),
			},
			WorkerProfiles: []*armredhatopenshift.WorkerProfile{
				{
					Name:       to.Ptr("worker"),
					Count:      to.Ptr[int32](3),
					DiskSizeGB: to.Ptr[int32](128),
					SubnetID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
					VMSize:     to.Ptr("Standard_D2s_v3"),
				}},
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OpenShiftCluster = armredhatopenshift.OpenShiftCluster{
	// 	Name: to.Ptr("resourceName"),
	// 	Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftClusters"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup/providers/Microsoft.RedHatOpenShift/OpenShiftClusters/resourceName"),
	// 	SystemData: &armredhatopenshift.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
	// 	},
	// 	Location: to.Ptr("location"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armredhatopenshift.ManagedServiceIdentity{
	// 		Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
	// 		UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
	// 			"": &armredhatopenshift.UserAssignedIdentity{
	// 			},
	// 		},
	// 	},
	// 	Properties: &armredhatopenshift.OpenShiftClusterProperties{
	// 		ApiserverProfile: &armredhatopenshift.APIServerProfile{
	// 			IP: to.Ptr("1.2.3.4"),
	// 			URL: to.Ptr("https://api.cluster.location.aroapp.io:6443/"),
	// 			Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
	// 		},
	// 		ClusterProfile: &armredhatopenshift.ClusterProfile{
	// 			Domain: to.Ptr("cluster.location.aroapp.io"),
	// 			ResourceGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
	// 			Version: to.Ptr("4.11.0"),
	// 		},
	// 		ConsoleProfile: &armredhatopenshift.ConsoleProfile{
	// 			URL: to.Ptr("https://console-openshift-console.apps.cluster.location.aroapp.io/"),
	// 		},
	// 		IngressProfiles: []*armredhatopenshift.IngressProfile{
	// 			{
	// 				Name: to.Ptr("default"),
	// 				IP: to.Ptr("1.2.3.4"),
	// 				Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
	// 		}},
	// 		MasterProfile: &armredhatopenshift.MasterProfile{
	// 			SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
	// 			VMSize: to.Ptr("Standard_D8s_v3"),
	// 		},
	// 		NetworkProfile: &armredhatopenshift.NetworkProfile{
	// 			PodCidr: to.Ptr("10.128.0.0/14"),
	// 			PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
	// 			ServiceCidr: to.Ptr("172.30.0.0/16"),
	// 		},
	// 		ProvisioningState: to.Ptr(armredhatopenshift.ProvisioningStateSucceeded),
	// 		ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
	// 			ClientID: to.Ptr("clientId"),
	// 		},
	// 		WorkerProfiles: []*armredhatopenshift.WorkerProfile{
	// 			{
	// 				Name: to.Ptr("worker"),
	// 				Count: to.Ptr[int32](3),
	// 				DiskSizeGB: to.Ptr[int32](128),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 		}},
	// 	},
	// }
}

Output:

func (*OpenShiftClustersClient) BeginDelete ¶

func (client *OpenShiftClustersClient) BeginDelete(ctx context.Context, resourceGroupName string, resourceName string, options *OpenShiftClustersClientBeginDeleteOptions) (*runtime.Poller[OpenShiftClustersClientDeleteResponse], error)

BeginDelete - The operation returns nothing. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
resourceName - The name of the OpenShift cluster resource.
options - OpenShiftClustersClientBeginDeleteOptions contains the optional parameters for the OpenShiftClustersClient.BeginDelete method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_Delete.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOpenShiftClustersClient().BeginDelete(ctx, "resourceGroup", "resourceName", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	_, err = poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
}

Output:

func (*OpenShiftClustersClient) BeginUpdate ¶

func (client *OpenShiftClustersClient) BeginUpdate(ctx context.Context, resourceGroupName string, resourceName string, parameters OpenShiftClusterUpdate, options *OpenShiftClustersClientBeginUpdateOptions) (*runtime.Poller[OpenShiftClustersClientUpdateResponse], error)

BeginUpdate - The operation returns properties of a OpenShift cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
resourceName - The name of the OpenShift cluster resource.
parameters - The OpenShift cluster resource.
options - OpenShiftClustersClientBeginUpdateOptions contains the optional parameters for the OpenShiftClustersClient.BeginUpdate method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_Update.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	poller, err := clientFactory.NewOpenShiftClustersClient().BeginUpdate(ctx, "resourceGroup", "resourceName", armredhatopenshift.OpenShiftClusterUpdate{
		Identity: &armredhatopenshift.ManagedServiceIdentity{
			Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
			UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
				"": {},
			},
		},
		Properties: &armredhatopenshift.OpenShiftClusterProperties{
			ApiserverProfile: &armredhatopenshift.APIServerProfile{
				Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
			},
			ClusterProfile: &armredhatopenshift.ClusterProfile{
				Domain:               to.Ptr("cluster.location.aroapp.io"),
				FipsValidatedModules: to.Ptr(armredhatopenshift.FipsValidatedModulesEnabled),
				PullSecret:           to.Ptr("{\"auths\":{\"registry.connect.redhat.com\":{\"auth\":\"\"},\"registry.redhat.io\":{\"auth\":\"\"}}}"),
				ResourceGroupID:      to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
			},
			ConsoleProfile: &armredhatopenshift.ConsoleProfile{},
			IngressProfiles: []*armredhatopenshift.IngressProfile{
				{
					Name:       to.Ptr("default"),
					Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
				}},
			MasterProfile: &armredhatopenshift.MasterProfile{
				EncryptionAtHost: to.Ptr(armredhatopenshift.EncryptionAtHostEnabled),
				SubnetID:         to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
				VMSize:           to.Ptr("Standard_D8s_v3"),
			},
			NetworkProfile: &armredhatopenshift.NetworkProfile{
				LoadBalancerProfile: &armredhatopenshift.LoadBalancerProfile{
					ManagedOutboundIPs: &armredhatopenshift.ManagedOutboundIPs{
						Count: to.Ptr[int32](1),
					},
				},
				PodCidr:          to.Ptr("10.128.0.0/14"),
				PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
				ServiceCidr:      to.Ptr("172.30.0.0/16"),
			},
			PlatformWorkloadIdentityProfile: &armredhatopenshift.PlatformWorkloadIdentityProfile{
				PlatformWorkloadIdentities: map[string]*armredhatopenshift.PlatformWorkloadIdentity{
					"": {},
				},
			},
			ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
				ClientID:     to.Ptr("clientId"),
				ClientSecret: to.Ptr("clientSecret"),
			},
			WorkerProfiles: []*armredhatopenshift.WorkerProfile{
				{
					Name:       to.Ptr("worker"),
					Count:      to.Ptr[int32](3),
					DiskSizeGB: to.Ptr[int32](128),
					SubnetID:   to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
					VMSize:     to.Ptr("Standard_D2s_v3"),
				}},
		},
		Tags: map[string]*string{
			"key": to.Ptr("value"),
		},
	}, nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	res, err := poller.PollUntilDone(ctx, nil)
	if err != nil {
		log.Fatalf("failed to pull the result: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OpenShiftCluster = armredhatopenshift.OpenShiftCluster{
	// 	Name: to.Ptr("resourceName"),
	// 	Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftClusters"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup/providers/Microsoft.RedHatOpenShift/OpenShiftClusters/resourceName"),
	// 	SystemData: &armredhatopenshift.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
	// 	},
	// 	Location: to.Ptr("location"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armredhatopenshift.ManagedServiceIdentity{
	// 		Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
	// 		UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
	// 			"": &armredhatopenshift.UserAssignedIdentity{
	// 			},
	// 		},
	// 	},
	// 	Properties: &armredhatopenshift.OpenShiftClusterProperties{
	// 		ApiserverProfile: &armredhatopenshift.APIServerProfile{
	// 			IP: to.Ptr("1.2.3.4"),
	// 			URL: to.Ptr("https://api.cluster.location.aroapp.io:6443/"),
	// 			Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
	// 		},
	// 		ClusterProfile: &armredhatopenshift.ClusterProfile{
	// 			Domain: to.Ptr("cluster.location.aroapp.io"),
	// 			ResourceGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
	// 			Version: to.Ptr("4.11.0"),
	// 		},
	// 		ConsoleProfile: &armredhatopenshift.ConsoleProfile{
	// 			URL: to.Ptr("https://console-openshift-console.apps.cluster.location.aroapp.io/"),
	// 		},
	// 		IngressProfiles: []*armredhatopenshift.IngressProfile{
	// 			{
	// 				Name: to.Ptr("default"),
	// 				IP: to.Ptr("1.2.3.4"),
	// 				Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
	// 		}},
	// 		MasterProfile: &armredhatopenshift.MasterProfile{
	// 			SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
	// 			VMSize: to.Ptr("Standard_D8s_v3"),
	// 		},
	// 		NetworkProfile: &armredhatopenshift.NetworkProfile{
	// 			PodCidr: to.Ptr("10.128.0.0/14"),
	// 			PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
	// 			ServiceCidr: to.Ptr("172.30.0.0/16"),
	// 		},
	// 		ProvisioningState: to.Ptr(armredhatopenshift.ProvisioningStateSucceeded),
	// 		ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
	// 			ClientID: to.Ptr("clientId"),
	// 		},
	// 		WorkerProfiles: []*armredhatopenshift.WorkerProfile{
	// 			{
	// 				Name: to.Ptr("worker"),
	// 				Count: to.Ptr[int32](3),
	// 				DiskSizeGB: to.Ptr[int32](128),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 		}},
	// 	},
	// }
}

Output:

func (*OpenShiftClustersClient) Get ¶

func (client *OpenShiftClustersClient) Get(ctx context.Context, resourceGroupName string, resourceName string, options *OpenShiftClustersClientGetOptions) (OpenShiftClustersClientGetResponse, error)

Get - The operation returns properties of a OpenShift cluster. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
resourceName - The name of the OpenShift cluster resource.
options - OpenShiftClustersClientGetOptions contains the optional parameters for the OpenShiftClustersClient.Get method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_Get.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOpenShiftClustersClient().Get(ctx, "resourceGroup", "resourceName", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OpenShiftCluster = armredhatopenshift.OpenShiftCluster{
	// 	Name: to.Ptr("resourceName"),
	// 	Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftClusters"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup/providers/Microsoft.RedHatOpenShift/OpenShiftClusters/resourceName"),
	// 	SystemData: &armredhatopenshift.SystemData{
	// 		CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
	// 		CreatedBy: to.Ptr("string"),
	// 		CreatedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
	// 		LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
	// 		LastModifiedBy: to.Ptr("string"),
	// 		LastModifiedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
	// 	},
	// 	Location: to.Ptr("location"),
	// 	Tags: map[string]*string{
	// 		"key": to.Ptr("value"),
	// 	},
	// 	Identity: &armredhatopenshift.ManagedServiceIdentity{
	// 		Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
	// 		UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
	// 			"": &armredhatopenshift.UserAssignedIdentity{
	// 			},
	// 		},
	// 	},
	// 	Properties: &armredhatopenshift.OpenShiftClusterProperties{
	// 		ApiserverProfile: &armredhatopenshift.APIServerProfile{
	// 			IP: to.Ptr("1.2.3.4"),
	// 			URL: to.Ptr("https://api.cluster.location.aroapp.io:6443/"),
	// 			Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
	// 		},
	// 		ClusterProfile: &armredhatopenshift.ClusterProfile{
	// 			Domain: to.Ptr("cluster.location.aroapp.io"),
	// 			ResourceGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
	// 			Version: to.Ptr("4.11.0"),
	// 		},
	// 		ConsoleProfile: &armredhatopenshift.ConsoleProfile{
	// 			URL: to.Ptr("https://console-openshift-console.apps.cluster.location.aroapp.io/"),
	// 		},
	// 		IngressProfiles: []*armredhatopenshift.IngressProfile{
	// 			{
	// 				Name: to.Ptr("default"),
	// 				IP: to.Ptr("1.2.3.4"),
	// 				Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
	// 		}},
	// 		MasterProfile: &armredhatopenshift.MasterProfile{
	// 			SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
	// 			VMSize: to.Ptr("Standard_D8s_v3"),
	// 		},
	// 		NetworkProfile: &armredhatopenshift.NetworkProfile{
	// 			LoadBalancerProfile: &armredhatopenshift.LoadBalancerProfile{
	// 				EffectiveOutboundIPs: []*armredhatopenshift.EffectiveOutboundIP{
	// 					{
	// 						ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup/providers/Microsoft.Network/publicIPAddresses/publicIPAddressName"),
	// 				}},
	// 				ManagedOutboundIPs: &armredhatopenshift.ManagedOutboundIPs{
	// 					Count: to.Ptr[int32](1),
	// 				},
	// 			},
	// 			PodCidr: to.Ptr("10.128.0.0/14"),
	// 			PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
	// 			ServiceCidr: to.Ptr("172.30.0.0/16"),
	// 		},
	// 		PlatformWorkloadIdentityProfile: &armredhatopenshift.PlatformWorkloadIdentityProfile{
	// 			PlatformWorkloadIdentities: map[string]*armredhatopenshift.PlatformWorkloadIdentity{
	// 				"": &armredhatopenshift.PlatformWorkloadIdentity{
	// 				},
	// 			},
	// 		},
	// 		ProvisioningState: to.Ptr(armredhatopenshift.ProvisioningStateSucceeded),
	// 		ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
	// 			ClientID: to.Ptr("clientId"),
	// 		},
	// 		WorkerProfiles: []*armredhatopenshift.WorkerProfile{
	// 			{
	// 				Name: to.Ptr("worker"),
	// 				Count: to.Ptr[int32](3),
	// 				DiskSizeGB: to.Ptr[int32](128),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 		}},
	// 		WorkerProfilesStatus: []*armredhatopenshift.WorkerProfile{
	// 			{
	// 				Name: to.Ptr("worker1"),
	// 				Count: to.Ptr[int32](1),
	// 				DiskSizeGB: to.Ptr[int32](128),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 			},
	// 			{
	// 				Name: to.Ptr("worker2"),
	// 				Count: to.Ptr[int32](1),
	// 				DiskSizeGB: to.Ptr[int32](128),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 			},
	// 			{
	// 				Name: to.Ptr("worker3"),
	// 				Count: to.Ptr[int32](1),
	// 				DiskSizeGB: to.Ptr[int32](128),
	// 				SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
	// 				VMSize: to.Ptr("Standard_D2s_v3"),
	// 		}},
	// 	},
	// }
}

Output:

func (*OpenShiftClustersClient) ListAdminCredentials ¶

func (client *OpenShiftClustersClient) ListAdminCredentials(ctx context.Context, resourceGroupName string, resourceName string, options *OpenShiftClustersClientListAdminCredentialsOptions) (OpenShiftClustersClientListAdminCredentialsResponse, error)

ListAdminCredentials - The operation returns the admin kubeconfig. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
resourceName - The name of the OpenShift cluster resource.
options - OpenShiftClustersClientListAdminCredentialsOptions contains the optional parameters for the OpenShiftClustersClient.ListAdminCredentials method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_ListAdminCredentials.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOpenShiftClustersClient().ListAdminCredentials(ctx, "resourceGroup", "resourceName", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OpenShiftClusterAdminKubeconfig = armredhatopenshift.OpenShiftClusterAdminKubeconfig{
	// 	Kubeconfig: to.Ptr("e30="),
	// }
}

Output:

func (*OpenShiftClustersClient) ListCredentials ¶

func (client *OpenShiftClustersClient) ListCredentials(ctx context.Context, resourceGroupName string, resourceName string, options *OpenShiftClustersClientListCredentialsOptions) (OpenShiftClustersClientListCredentialsResponse, error)

ListCredentials - The operation returns the credentials. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
resourceName - The name of the OpenShift cluster resource.
options - OpenShiftClustersClientListCredentialsOptions contains the optional parameters for the OpenShiftClustersClient.ListCredentials method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_ListCredentials.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOpenShiftClustersClient().ListCredentials(ctx, "resourceGroup", "resourceName", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OpenShiftClusterCredentials = armredhatopenshift.OpenShiftClusterCredentials{
	// 	KubeadminPassword: to.Ptr("password"),
	// 	KubeadminUsername: to.Ptr("kubeadmin"),
	// }
}

Output:

func (*OpenShiftClustersClient) NewListByResourceGroupPager ¶

func (client *OpenShiftClustersClient) NewListByResourceGroupPager(resourceGroupName string, options *OpenShiftClustersClientListByResourceGroupOptions) *runtime.Pager[OpenShiftClustersClientListByResourceGroupResponse]

NewListByResourceGroupPager - The operation returns properties of each OpenShift cluster.

Generated from API version 2025-07-25

resourceGroupName - The name of the resource group. The name is case insensitive.
options - OpenShiftClustersClientListByResourceGroupOptions contains the optional parameters for the OpenShiftClustersClient.NewListByResourceGroupPager method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_ListByResourceGroup.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOpenShiftClustersClient().NewListByResourceGroupPager("resourceGroup", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OpenShiftClusterList = armredhatopenshift.OpenShiftClusterList{
		// 	Value: []*armredhatopenshift.OpenShiftCluster{
		// 		{
		// 			Name: to.Ptr("resourceName"),
		// 			Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftClusters"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup/providers/Microsoft.RedHatOpenShift/OpenShiftClusters/resourceName"),
		// 			SystemData: &armredhatopenshift.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
		// 				CreatedBy: to.Ptr("string"),
		// 				CreatedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("string"),
		// 				LastModifiedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
		// 			},
		// 			Location: to.Ptr("location"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Identity: &armredhatopenshift.ManagedServiceIdentity{
		// 				Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
		// 				UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
		// 					"": &armredhatopenshift.UserAssignedIdentity{
		// 					},
		// 				},
		// 			},
		// 			Properties: &armredhatopenshift.OpenShiftClusterProperties{
		// 				ApiserverProfile: &armredhatopenshift.APIServerProfile{
		// 					IP: to.Ptr("1.2.3.4"),
		// 					URL: to.Ptr("https://api.cluster.location.aroapp.io:6443/"),
		// 					Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
		// 				},
		// 				ClusterProfile: &armredhatopenshift.ClusterProfile{
		// 					Domain: to.Ptr("cluster.location.aroapp.io"),
		// 					ResourceGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
		// 					Version: to.Ptr("4.11.0"),
		// 				},
		// 				ConsoleProfile: &armredhatopenshift.ConsoleProfile{
		// 					URL: to.Ptr("https://console-openshift-console.apps.cluster.location.aroapp.io/"),
		// 				},
		// 				IngressProfiles: []*armredhatopenshift.IngressProfile{
		// 					{
		// 						Name: to.Ptr("default"),
		// 						IP: to.Ptr("1.2.3.4"),
		// 						Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
		// 				}},
		// 				MasterProfile: &armredhatopenshift.MasterProfile{
		// 					SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
		// 					VMSize: to.Ptr("Standard_D8s_v3"),
		// 				},
		// 				NetworkProfile: &armredhatopenshift.NetworkProfile{
		// 					LoadBalancerProfile: &armredhatopenshift.LoadBalancerProfile{
		// 						EffectiveOutboundIPs: []*armredhatopenshift.EffectiveOutboundIP{
		// 							{
		// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup/providers/Microsoft.Network/publicIPAddresses/publicIPAddressName"),
		// 						}},
		// 						ManagedOutboundIPs: &armredhatopenshift.ManagedOutboundIPs{
		// 							Count: to.Ptr[int32](1),
		// 						},
		// 					},
		// 					PodCidr: to.Ptr("10.128.0.0/14"),
		// 					PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
		// 					ServiceCidr: to.Ptr("172.30.0.0/16"),
		// 				},
		// 				PlatformWorkloadIdentityProfile: &armredhatopenshift.PlatformWorkloadIdentityProfile{
		// 					PlatformWorkloadIdentities: map[string]*armredhatopenshift.PlatformWorkloadIdentity{
		// 						"": &armredhatopenshift.PlatformWorkloadIdentity{
		// 						},
		// 					},
		// 				},
		// 				ProvisioningState: to.Ptr(armredhatopenshift.ProvisioningStateSucceeded),
		// 				ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
		// 					ClientID: to.Ptr("clientId"),
		// 				},
		// 				WorkerProfiles: []*armredhatopenshift.WorkerProfile{
		// 					{
		// 						Name: to.Ptr("worker"),
		// 						Count: to.Ptr[int32](3),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 				}},
		// 				WorkerProfilesStatus: []*armredhatopenshift.WorkerProfile{
		// 					{
		// 						Name: to.Ptr("worker1"),
		// 						Count: to.Ptr[int32](1),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 					},
		// 					{
		// 						Name: to.Ptr("worker2"),
		// 						Count: to.Ptr[int32](1),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 					},
		// 					{
		// 						Name: to.Ptr("worker3"),
		// 						Count: to.Ptr[int32](1),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 				}},
		// 			},
		// 	}},
		// }
	}
}

Output:

func (*OpenShiftClustersClient) NewListPager ¶

func (client *OpenShiftClustersClient) NewListPager(options *OpenShiftClustersClientListOptions) *runtime.Pager[OpenShiftClustersClientListResponse]

NewListPager - The operation returns properties of each OpenShift cluster.

Generated from API version 2025-07-25

options - OpenShiftClustersClientListOptions contains the optional parameters for the OpenShiftClustersClient.NewListPager method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftClusters_List.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOpenShiftClustersClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OpenShiftClusterList = armredhatopenshift.OpenShiftClusterList{
		// 	Value: []*armredhatopenshift.OpenShiftCluster{
		// 		{
		// 			Name: to.Ptr("resourceName"),
		// 			Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftClusters"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroup/providers/Microsoft.RedHatOpenShift/OpenShiftClusters/resourceName"),
		// 			SystemData: &armredhatopenshift.SystemData{
		// 				CreatedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
		// 				CreatedBy: to.Ptr("string"),
		// 				CreatedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
		// 				LastModifiedAt: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2020-02-03T01:01:01.107Z"); return t}()),
		// 				LastModifiedBy: to.Ptr("string"),
		// 				LastModifiedByType: to.Ptr(armredhatopenshift.CreatedByTypeApplication),
		// 			},
		// 			Location: to.Ptr("location"),
		// 			Tags: map[string]*string{
		// 				"key": to.Ptr("value"),
		// 			},
		// 			Identity: &armredhatopenshift.ManagedServiceIdentity{
		// 				Type: to.Ptr(armredhatopenshift.ManagedServiceIdentityTypeUserAssigned),
		// 				UserAssignedIdentities: map[string]*armredhatopenshift.UserAssignedIdentity{
		// 					"": &armredhatopenshift.UserAssignedIdentity{
		// 					},
		// 				},
		// 			},
		// 			Properties: &armredhatopenshift.OpenShiftClusterProperties{
		// 				ApiserverProfile: &armredhatopenshift.APIServerProfile{
		// 					IP: to.Ptr("1.2.3.4"),
		// 					URL: to.Ptr("https://api.cluster.location.aroapp.io:6443/"),
		// 					Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
		// 				},
		// 				ClusterProfile: &armredhatopenshift.ClusterProfile{
		// 					Domain: to.Ptr("cluster.location.aroapp.io"),
		// 					ResourceGroupID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup"),
		// 					Version: to.Ptr("4.11.0"),
		// 				},
		// 				ConsoleProfile: &armredhatopenshift.ConsoleProfile{
		// 					URL: to.Ptr("https://console-openshift-console.apps.cluster.location.aroapp.io/"),
		// 				},
		// 				IngressProfiles: []*armredhatopenshift.IngressProfile{
		// 					{
		// 						Name: to.Ptr("default"),
		// 						IP: to.Ptr("1.2.3.4"),
		// 						Visibility: to.Ptr(armredhatopenshift.VisibilityPublic),
		// 				}},
		// 				MasterProfile: &armredhatopenshift.MasterProfile{
		// 					SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/master"),
		// 					VMSize: to.Ptr("Standard_D8s_v3"),
		// 				},
		// 				NetworkProfile: &armredhatopenshift.NetworkProfile{
		// 					LoadBalancerProfile: &armredhatopenshift.LoadBalancerProfile{
		// 						EffectiveOutboundIPs: []*armredhatopenshift.EffectiveOutboundIP{
		// 							{
		// 								ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/clusterResourceGroup/providers/Microsoft.Network/publicIPAddresses/publicIPAddressName"),
		// 						}},
		// 						ManagedOutboundIPs: &armredhatopenshift.ManagedOutboundIPs{
		// 							Count: to.Ptr[int32](1),
		// 						},
		// 					},
		// 					PodCidr: to.Ptr("10.128.0.0/14"),
		// 					PreconfiguredNSG: to.Ptr(armredhatopenshift.PreconfiguredNSGDisabled),
		// 					ServiceCidr: to.Ptr("172.30.0.0/16"),
		// 				},
		// 				PlatformWorkloadIdentityProfile: &armredhatopenshift.PlatformWorkloadIdentityProfile{
		// 					PlatformWorkloadIdentities: map[string]*armredhatopenshift.PlatformWorkloadIdentity{
		// 						"": &armredhatopenshift.PlatformWorkloadIdentity{
		// 						},
		// 					},
		// 				},
		// 				ProvisioningState: to.Ptr(armredhatopenshift.ProvisioningStateSucceeded),
		// 				ServicePrincipalProfile: &armredhatopenshift.ServicePrincipalProfile{
		// 					ClientID: to.Ptr("clientId"),
		// 				},
		// 				WorkerProfiles: []*armredhatopenshift.WorkerProfile{
		// 					{
		// 						Name: to.Ptr("worker"),
		// 						Count: to.Ptr[int32](3),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 				}},
		// 				WorkerProfilesStatus: []*armredhatopenshift.WorkerProfile{
		// 					{
		// 						Name: to.Ptr("worker1"),
		// 						Count: to.Ptr[int32](1),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 					},
		// 					{
		// 						Name: to.Ptr("worker2"),
		// 						Count: to.Ptr[int32](1),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 					},
		// 					{
		// 						Name: to.Ptr("worker3"),
		// 						Count: to.Ptr[int32](1),
		// 						DiskSizeGB: to.Ptr[int32](128),
		// 						SubnetID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/vnetResourceGroup/providers/Microsoft.Network/virtualNetworks/vnet/subnets/worker"),
		// 						VMSize: to.Ptr("Standard_D2s_v3"),
		// 				}},
		// 			},
		// 	}},
		// }
	}
}

Output:

type OpenShiftClustersClientBeginCreateOrUpdateOptions ¶

type OpenShiftClustersClientBeginCreateOrUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

OpenShiftClustersClientBeginCreateOrUpdateOptions contains the optional parameters for the OpenShiftClustersClient.BeginCreateOrUpdate method.

type OpenShiftClustersClientBeginDeleteOptions ¶

type OpenShiftClustersClientBeginDeleteOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

OpenShiftClustersClientBeginDeleteOptions contains the optional parameters for the OpenShiftClustersClient.BeginDelete method.

type OpenShiftClustersClientBeginUpdateOptions ¶

type OpenShiftClustersClientBeginUpdateOptions struct {
	// Resumes the long-running operation from the provided token.
	ResumeToken string
}

OpenShiftClustersClientBeginUpdateOptions contains the optional parameters for the OpenShiftClustersClient.BeginUpdate method.

type OpenShiftClustersClientCreateOrUpdateResponse ¶

type OpenShiftClustersClientCreateOrUpdateResponse struct {
	// OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
	OpenShiftCluster
}

OpenShiftClustersClientCreateOrUpdateResponse contains the response from method OpenShiftClustersClient.BeginCreateOrUpdate.

type OpenShiftClustersClientDeleteResponse ¶

type OpenShiftClustersClientDeleteResponse struct {
}

OpenShiftClustersClientDeleteResponse contains the response from method OpenShiftClustersClient.BeginDelete.

type OpenShiftClustersClientGetOptions ¶

type OpenShiftClustersClientGetOptions struct {
}

OpenShiftClustersClientGetOptions contains the optional parameters for the OpenShiftClustersClient.Get method.

type OpenShiftClustersClientGetResponse ¶

type OpenShiftClustersClientGetResponse struct {
	// OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
	OpenShiftCluster
}

OpenShiftClustersClientGetResponse contains the response from method OpenShiftClustersClient.Get.

type OpenShiftClustersClientListAdminCredentialsOptions ¶

type OpenShiftClustersClientListAdminCredentialsOptions struct {
}

OpenShiftClustersClientListAdminCredentialsOptions contains the optional parameters for the OpenShiftClustersClient.ListAdminCredentials method.

type OpenShiftClustersClientListAdminCredentialsResponse ¶

type OpenShiftClustersClientListAdminCredentialsResponse struct {
	// OpenShiftClusterAdminKubeconfig represents an OpenShift cluster's admin kubeconfig.
	OpenShiftClusterAdminKubeconfig
}

OpenShiftClustersClientListAdminCredentialsResponse contains the response from method OpenShiftClustersClient.ListAdminCredentials.

type OpenShiftClustersClientListByResourceGroupOptions ¶

type OpenShiftClustersClientListByResourceGroupOptions struct {
}

OpenShiftClustersClientListByResourceGroupOptions contains the optional parameters for the OpenShiftClustersClient.NewListByResourceGroupPager method.

type OpenShiftClustersClientListByResourceGroupResponse ¶

type OpenShiftClustersClientListByResourceGroupResponse struct {
	// OpenShiftClusterList represents a list of OpenShift clusters.
	OpenShiftClusterList
}

OpenShiftClustersClientListByResourceGroupResponse contains the response from method OpenShiftClustersClient.NewListByResourceGroupPager.

type OpenShiftClustersClientListCredentialsOptions ¶

type OpenShiftClustersClientListCredentialsOptions struct {
}

OpenShiftClustersClientListCredentialsOptions contains the optional parameters for the OpenShiftClustersClient.ListCredentials method.

type OpenShiftClustersClientListCredentialsResponse ¶

type OpenShiftClustersClientListCredentialsResponse struct {
	// OpenShiftClusterCredentials represents an OpenShift cluster's credentials.
	OpenShiftClusterCredentials
}

OpenShiftClustersClientListCredentialsResponse contains the response from method OpenShiftClustersClient.ListCredentials.

type OpenShiftClustersClientListOptions ¶

type OpenShiftClustersClientListOptions struct {
}

OpenShiftClustersClientListOptions contains the optional parameters for the OpenShiftClustersClient.NewListPager method.

type OpenShiftClustersClientListResponse ¶

type OpenShiftClustersClientListResponse struct {
	// OpenShiftClusterList represents a list of OpenShift clusters.
	OpenShiftClusterList
}

OpenShiftClustersClientListResponse contains the response from method OpenShiftClustersClient.NewListPager.

type OpenShiftClustersClientUpdateResponse ¶

type OpenShiftClustersClientUpdateResponse struct {
	// OpenShiftCluster represents an Azure Red Hat OpenShift cluster.
	OpenShiftCluster
}

OpenShiftClustersClientUpdateResponse contains the response from method OpenShiftClustersClient.BeginUpdate.

type OpenShiftVersion ¶

type OpenShiftVersion struct {
	// The properties for the OpenShiftVersion resource.
	Properties *OpenShiftVersionProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

OpenShiftVersion represents an OpenShift version that can be installed.

func (OpenShiftVersion) MarshalJSON ¶

func (o OpenShiftVersion) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftVersion.

func (*OpenShiftVersion) UnmarshalJSON ¶

func (o *OpenShiftVersion) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftVersion.

type OpenShiftVersionList ¶

type OpenShiftVersionList struct {
	// Next Link to next operation.
	NextLink *string

	// The List of available versions.
	Value []*OpenShiftVersion
}

OpenShiftVersionList represents a List of available versions.

func (OpenShiftVersionList) MarshalJSON ¶

func (o OpenShiftVersionList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftVersionList.

func (*OpenShiftVersionList) UnmarshalJSON ¶

func (o *OpenShiftVersionList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftVersionList.

type OpenShiftVersionProperties ¶

type OpenShiftVersionProperties struct {
	// Version represents the version to create the cluster at.
	Version *string
}

OpenShiftVersionProperties represents the properties of an OpenShiftVersion.

func (OpenShiftVersionProperties) MarshalJSON ¶

func (o OpenShiftVersionProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OpenShiftVersionProperties.

func (*OpenShiftVersionProperties) UnmarshalJSON ¶

func (o *OpenShiftVersionProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OpenShiftVersionProperties.

type OpenShiftVersionsClient ¶

type OpenShiftVersionsClient struct {
	// contains filtered or unexported fields
}

OpenShiftVersionsClient contains the methods for the OpenShiftVersions group. Don't use this type directly, use NewOpenShiftVersionsClient() instead.

func NewOpenShiftVersionsClient ¶

func NewOpenShiftVersionsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*OpenShiftVersionsClient, error)

NewOpenShiftVersionsClient creates a new instance of OpenShiftVersionsClient with the specified values.

subscriptionID - The ID of the target subscription. The value must be an UUID.
credential - used to authorize requests. Usually a credential from azidentity.
options - Contains optional client configuration. Pass nil to accept the default values.

func (*OpenShiftVersionsClient) Get ¶

func (client *OpenShiftVersionsClient) Get(ctx context.Context, location string, openShiftVersion string, options *OpenShiftVersionsClientGetOptions) (OpenShiftVersionsClientGetResponse, error)

Get - This operation returns installable OpenShift version as a string. If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

location - The name of the Azure region.
openShiftVersion - The desired version value of the OpenShiftVersion resource.
options - OpenShiftVersionsClientGetOptions contains the optional parameters for the OpenShiftVersionsClient.Get method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftVersions_Get.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewOpenShiftVersionsClient().Get(ctx, "location", "4.14.40", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.OpenShiftVersion = armredhatopenshift.OpenShiftVersion{
	// 	Name: to.Ptr("4.10.20"),
	// 	Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftVersion"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroupName/providers/resourceProviderNamespace/resourceType/resourceName"),
	// 	Properties: &armredhatopenshift.OpenShiftVersionProperties{
	// 		Version: to.Ptr("4.10.20"),
	// 	},
	// }
}

Output:

func (*OpenShiftVersionsClient) NewListPager ¶

func (client *OpenShiftVersionsClient) NewListPager(location string, options *OpenShiftVersionsClientListOptions) *runtime.Pager[OpenShiftVersionsClientListResponse]

NewListPager - The operation returns the installable OpenShift versions as a string.

Generated from API version 2025-07-25

location - The name of the Azure region.
options - OpenShiftVersionsClientListOptions contains the optional parameters for the OpenShiftVersionsClient.NewListPager method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/OpenShiftVersions_List.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOpenShiftVersionsClient().NewListPager("location", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OpenShiftVersionList = armredhatopenshift.OpenShiftVersionList{
		// 	Value: []*armredhatopenshift.OpenShiftVersion{
		// 		{
		// 			Name: to.Ptr("4.10.20"),
		// 			Type: to.Ptr("Microsoft.RedHatOpenShift/OpenShiftVersion"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroupName/providers/resourceProviderNamespace/resourceType/resourceName"),
		// 			Properties: &armredhatopenshift.OpenShiftVersionProperties{
		// 				Version: to.Ptr("4.10.20"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type OpenShiftVersionsClientGetOptions ¶

type OpenShiftVersionsClientGetOptions struct {
}

OpenShiftVersionsClientGetOptions contains the optional parameters for the OpenShiftVersionsClient.Get method.

type OpenShiftVersionsClientGetResponse ¶

type OpenShiftVersionsClientGetResponse struct {
	// OpenShiftVersion represents an OpenShift version that can be installed.
	OpenShiftVersion
}

OpenShiftVersionsClientGetResponse contains the response from method OpenShiftVersionsClient.Get.

type OpenShiftVersionsClientListOptions ¶

type OpenShiftVersionsClientListOptions struct {
}

OpenShiftVersionsClientListOptions contains the optional parameters for the OpenShiftVersionsClient.NewListPager method.

type OpenShiftVersionsClientListResponse ¶

type OpenShiftVersionsClientListResponse struct {
	// OpenShiftVersionList represents a List of available versions.
	OpenShiftVersionList
}

OpenShiftVersionsClientListResponse contains the response from method OpenShiftVersionsClient.NewListPager.

type Operation ¶

type Operation struct {
	// The object that describes the operation.
	Display *Display

	// Operation name: {provider}/{resource}/{operation}.
	Name *string

	// Sources of requests to this operation. Comma separated list with valid values user or system, e.g. "user,system".
	Origin *string
}

Operation represents an RP operation.

func (Operation) MarshalJSON ¶

func (o Operation) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type Operation.

func (*Operation) UnmarshalJSON ¶

func (o *Operation) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type Operation.

type OperationList ¶

type OperationList struct {
	// The link used to get the next page of operations.
	NextLink *string

	// List of operations supported by the resource provider.
	Value []*Operation
}

OperationList represents an RP operation list.

func (OperationList) MarshalJSON ¶

func (o OperationList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type OperationList.

func (*OperationList) UnmarshalJSON ¶

func (o *OperationList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type OperationList.

type OperationsClient ¶

type OperationsClient struct {
	// contains filtered or unexported fields
}

OperationsClient contains the methods for the Operations group. Don't use this type directly, use NewOperationsClient() instead.

func NewOperationsClient ¶

func NewOperationsClient(credential azcore.TokenCredential, options *arm.ClientOptions) (*OperationsClient, error)

NewOperationsClient creates a new instance of OperationsClient with the specified values.

credential - used to authorize requests. Usually a credential from azidentity.
options - Contains optional client configuration. Pass nil to accept the default values.

func (*OperationsClient) NewListPager ¶

func (client *OperationsClient) NewListPager(options *OperationsClientListOptions) *runtime.Pager[OperationsClientListResponse]

NewListPager - The operation returns the RP operations.

Generated from API version 2025-07-25

options - OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/Operations_List.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewOperationsClient().NewListPager(nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.OperationList = armredhatopenshift.OperationList{
		// 	Value: []*armredhatopenshift.Operation{
		// 		{
		// 			Name: to.Ptr("Microsoft.RedHatOpenShift/openShiftClusters/read"),
		// 			Display: &armredhatopenshift.Display{
		// 				Operation: to.Ptr("Read OpenShift cluster"),
		// 				Provider: to.Ptr("Azure Red Hat OpenShift"),
		// 				Resource: to.Ptr("openShiftClusters"),
		// 			},
		// 	}},
		// }
	}
}

Output:

type OperationsClientListOptions ¶

type OperationsClientListOptions struct {
}

OperationsClientListOptions contains the optional parameters for the OperationsClient.NewListPager method.

type OperationsClientListResponse ¶

type OperationsClientListResponse struct {
	// OperationList represents an RP operation list.
	OperationList
}

OperationsClientListResponse contains the response from method OperationsClient.NewListPager.

type OutboundType ¶

type OutboundType string

OutboundType - The outbound routing strategy used to provide your cluster egress to the internet.

const (
	OutboundTypeLoadbalancer       OutboundType = "Loadbalancer"
	OutboundTypeUserDefinedRouting OutboundType = "UserDefinedRouting"
)

func PossibleOutboundTypeValues ¶

func PossibleOutboundTypeValues() []OutboundType

PossibleOutboundTypeValues returns the possible values for the OutboundType const type.

type PlatformWorkloadIdentity ¶

type PlatformWorkloadIdentity struct {
	// The resource ID of the PlatformWorkloadIdentity resource
	ResourceID *string

	// READ-ONLY; The ClientID of the PlatformWorkloadIdentity resource
	ClientID *string

	// READ-ONLY; The ObjectID of the PlatformWorkloadIdentity resource
	ObjectID *string
}

PlatformWorkloadIdentity stores information representing a single workload identity.

func (PlatformWorkloadIdentity) MarshalJSON ¶

func (p PlatformWorkloadIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformWorkloadIdentity.

func (*PlatformWorkloadIdentity) UnmarshalJSON ¶

func (p *PlatformWorkloadIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformWorkloadIdentity.

type PlatformWorkloadIdentityProfile ¶

type PlatformWorkloadIdentityProfile struct {
	// Dictionary of
	PlatformWorkloadIdentities map[string]*PlatformWorkloadIdentity

	// UpgradeableTo stores a single OpenShift version a workload identity cluster can be upgraded to
	UpgradeableTo *string
}

PlatformWorkloadIdentityProfile encapsulates all information that is specific to workload identity clusters.

func (PlatformWorkloadIdentityProfile) MarshalJSON ¶

func (p PlatformWorkloadIdentityProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformWorkloadIdentityProfile.

func (*PlatformWorkloadIdentityProfile) UnmarshalJSON ¶

func (p *PlatformWorkloadIdentityProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformWorkloadIdentityProfile.

type PlatformWorkloadIdentityRole ¶

type PlatformWorkloadIdentityRole struct {
	// OperatorName represents the name of the operator that this role is for.
	OperatorName *string

	// RoleDefinitionID represents the resource ID of the role definition.
	RoleDefinitionID *string

	// RoleDefinitionName represents the name of the role.
	RoleDefinitionName *string
}

PlatformWorkloadIdentityRole represents a mapping from a particular OCP operator to the built-in role that should be assigned to that operator's corresponding managed identity.

func (PlatformWorkloadIdentityRole) MarshalJSON ¶

func (p PlatformWorkloadIdentityRole) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformWorkloadIdentityRole.

func (*PlatformWorkloadIdentityRole) UnmarshalJSON ¶

func (p *PlatformWorkloadIdentityRole) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformWorkloadIdentityRole.

type PlatformWorkloadIdentityRoleSet ¶

type PlatformWorkloadIdentityRoleSet struct {
	// The properties for the PlatformWorkloadIdentityRoleSet resource.
	Properties *PlatformWorkloadIdentityRoleSetProperties

	// READ-ONLY; Fully qualified resource ID for the resource. E.g. "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}"
	ID *string

	// READ-ONLY; The name of the resource
	Name *string

	// READ-ONLY; Azure Resource Manager metadata containing createdBy and modifiedBy information.
	SystemData *SystemData

	// READ-ONLY; The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"
	Type *string
}

PlatformWorkloadIdentityRoleSet represents a mapping from the names of OCP operators to the built-in roles that should be assigned to those operator's corresponding managed identities for a particular OCP version.

func (PlatformWorkloadIdentityRoleSet) MarshalJSON ¶

func (p PlatformWorkloadIdentityRoleSet) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformWorkloadIdentityRoleSet.

func (*PlatformWorkloadIdentityRoleSet) UnmarshalJSON ¶

func (p *PlatformWorkloadIdentityRoleSet) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformWorkloadIdentityRoleSet.

type PlatformWorkloadIdentityRoleSetClient ¶

type PlatformWorkloadIdentityRoleSetClient struct {
	// contains filtered or unexported fields
}

PlatformWorkloadIdentityRoleSetClient contains the methods for the PlatformWorkloadIdentityRoleSet group. Don't use this type directly, use NewPlatformWorkloadIdentityRoleSetClient() instead.

func NewPlatformWorkloadIdentityRoleSetClient ¶

func NewPlatformWorkloadIdentityRoleSetClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PlatformWorkloadIdentityRoleSetClient, error)

NewPlatformWorkloadIdentityRoleSetClient creates a new instance of PlatformWorkloadIdentityRoleSetClient with the specified values.

subscriptionID - The ID of the target subscription. The value must be an UUID.
credential - used to authorize requests. Usually a credential from azidentity.
options - Contains optional client configuration. Pass nil to accept the default values.

func (*PlatformWorkloadIdentityRoleSetClient) Get ¶

func (client *PlatformWorkloadIdentityRoleSetClient) Get(ctx context.Context, location string, openShiftMinorVersion string, options *PlatformWorkloadIdentityRoleSetClientGetOptions) (PlatformWorkloadIdentityRoleSetClientGetResponse, error)

Get - This operation returns Platform Workload Identity Role Set as a string If the operation fails it returns an *azcore.ResponseError type.

Generated from API version 2025-07-25

location - The name of the Azure region.
openShiftMinorVersion - The desired version value of the PlatformWorkloadIdentityRoleSet resource.
options - PlatformWorkloadIdentityRoleSetClientGetOptions contains the optional parameters for the PlatformWorkloadIdentityRoleSetClient.Get method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/PlatformWorkloadIdentityRoleSet_Get.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	res, err := clientFactory.NewPlatformWorkloadIdentityRoleSetClient().Get(ctx, "location", "4.14", nil)
	if err != nil {
		log.Fatalf("failed to finish the request: %v", err)
	}
	// You could use response here. We use blank identifier for just demo purposes.
	_ = res
	// If the HTTP response code is 200 as defined in example definition, your response structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
	// res.PlatformWorkloadIdentityRoleSet = armredhatopenshift.PlatformWorkloadIdentityRoleSet{
	// 	Name: to.Ptr("4.14"),
	// 	Type: to.Ptr("Microsoft.RedHatOpenShift/PlatformWorkloadIdentityRoleSet"),
	// 	ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroupName/providers/resourceProviderNamespace/resourceType/resourceName"),
	// 	Properties: &armredhatopenshift.PlatformWorkloadIdentityRoleSetProperties{
	// 		OpenShiftVersion: to.Ptr("4.14"),
	// 		PlatformWorkloadIdentityRoles: []*armredhatopenshift.PlatformWorkloadIdentityRole{
	// 			{
	// 				OperatorName: to.Ptr("aro-operator"),
	// 				RoleDefinitionID: to.Ptr("/providers/Microsoft.Authorization/roleDefinitions/00000000-0000-0000-0000-000000000000"),
	// 				RoleDefinitionName: to.Ptr("Azure Red Hat OpenShift Service Operator"),
	// 		}},
	// 	},
	// }
}

Output:

type PlatformWorkloadIdentityRoleSetClientGetOptions ¶

type PlatformWorkloadIdentityRoleSetClientGetOptions struct {
}

PlatformWorkloadIdentityRoleSetClientGetOptions contains the optional parameters for the PlatformWorkloadIdentityRoleSetClient.Get method.

type PlatformWorkloadIdentityRoleSetClientGetResponse ¶

type PlatformWorkloadIdentityRoleSetClientGetResponse struct {
	// PlatformWorkloadIdentityRoleSet represents a mapping from the names of OCP operators to the built-in roles that should
	// be assigned to those operator's corresponding managed identities for a particular OCP version.
	PlatformWorkloadIdentityRoleSet
}

PlatformWorkloadIdentityRoleSetClientGetResponse contains the response from method PlatformWorkloadIdentityRoleSetClient.Get.

type PlatformWorkloadIdentityRoleSetList ¶

type PlatformWorkloadIdentityRoleSetList struct {
	// Next Link to next operation.
	NextLink *string

	// The list of role sets.
	Value []*PlatformWorkloadIdentityRoleSet
}

PlatformWorkloadIdentityRoleSetList represents a List of role sets.

func (PlatformWorkloadIdentityRoleSetList) MarshalJSON ¶

func (p PlatformWorkloadIdentityRoleSetList) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformWorkloadIdentityRoleSetList.

func (*PlatformWorkloadIdentityRoleSetList) UnmarshalJSON ¶

func (p *PlatformWorkloadIdentityRoleSetList) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformWorkloadIdentityRoleSetList.

type PlatformWorkloadIdentityRoleSetProperties ¶

type PlatformWorkloadIdentityRoleSetProperties struct {
	// OpenShiftVersion represents the version associated with this set of roles.
	OpenShiftVersion *string

	// PlatformWorkloadIdentityRoles represents the set of roles associated with this version.
	PlatformWorkloadIdentityRoles []*PlatformWorkloadIdentityRole
}

PlatformWorkloadIdentityRoleSetProperties represents the properties of a PlatformWorkloadIdentityRoleSet resource.

func (PlatformWorkloadIdentityRoleSetProperties) MarshalJSON ¶

func (p PlatformWorkloadIdentityRoleSetProperties) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type PlatformWorkloadIdentityRoleSetProperties.

func (*PlatformWorkloadIdentityRoleSetProperties) UnmarshalJSON ¶

func (p *PlatformWorkloadIdentityRoleSetProperties) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type PlatformWorkloadIdentityRoleSetProperties.

type PlatformWorkloadIdentityRoleSetsClient ¶

type PlatformWorkloadIdentityRoleSetsClient struct {
	// contains filtered or unexported fields
}

PlatformWorkloadIdentityRoleSetsClient contains the methods for the PlatformWorkloadIdentityRoleSets group. Don't use this type directly, use NewPlatformWorkloadIdentityRoleSetsClient() instead.

func NewPlatformWorkloadIdentityRoleSetsClient ¶

func NewPlatformWorkloadIdentityRoleSetsClient(subscriptionID string, credential azcore.TokenCredential, options *arm.ClientOptions) (*PlatformWorkloadIdentityRoleSetsClient, error)

NewPlatformWorkloadIdentityRoleSetsClient creates a new instance of PlatformWorkloadIdentityRoleSetsClient with the specified values.

subscriptionID - The ID of the target subscription. The value must be an UUID.
credential - used to authorize requests. Usually a credential from azidentity.
options - Contains optional client configuration. Pass nil to accept the default values.

func (*PlatformWorkloadIdentityRoleSetsClient) NewListPager ¶

func (client *PlatformWorkloadIdentityRoleSetsClient) NewListPager(location string, options *PlatformWorkloadIdentityRoleSetsClientListOptions) *runtime.Pager[PlatformWorkloadIdentityRoleSetsClientListResponse]

NewListPager - This operation returns a list of Platform Workload Identity Role Sets as a string

Generated from API version 2025-07-25

location - The name of the Azure region.
options - PlatformWorkloadIdentityRoleSetsClientListOptions contains the optional parameters for the PlatformWorkloadIdentityRoleSetsClient.NewListPager method.

Example ¶

Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/6e34caed36815fc876c8e8c0371db76f809e52e8/specification/redhatopenshift/resource-manager/Microsoft.RedHatOpenShift/OpenShiftClusters/stable/2025-07-25/examples/PlatformWorkloadIdentityRoleSets_List.json

package main

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/redhatopenshift/armredhatopenshift/v2"
)

func main() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armredhatopenshift.NewClientFactory("", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewPlatformWorkloadIdentityRoleSetsClient().NewListPager("location", nil)
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.PlatformWorkloadIdentityRoleSetList = armredhatopenshift.PlatformWorkloadIdentityRoleSetList{
		// 	Value: []*armredhatopenshift.PlatformWorkloadIdentityRoleSet{
		// 		{
		// 			Name: to.Ptr("4.14"),
		// 			Type: to.Ptr("Microsoft.RedHatOpenShift/PlatformWorkloadIdentityRoleSet"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resourceGroupName/providers/resourceProviderNamespace/resourceType/resourceName"),
		// 			Properties: &armredhatopenshift.PlatformWorkloadIdentityRoleSetProperties{
		// 				OpenShiftVersion: to.Ptr("4.14"),
		// 				PlatformWorkloadIdentityRoles: []*armredhatopenshift.PlatformWorkloadIdentityRole{
		// 					{
		// 						OperatorName: to.Ptr("aro-operator"),
		// 						RoleDefinitionID: to.Ptr("/providers/Microsoft.Authorization/roleDefinitions/00000000-0000-0000-0000-000000000000"),
		// 						RoleDefinitionName: to.Ptr("Azure Red Hat OpenShift Service Operator"),
		// 				}},
		// 			},
		// 	}},
		// }
	}
}

Output:

type PlatformWorkloadIdentityRoleSetsClientListOptions ¶

type PlatformWorkloadIdentityRoleSetsClientListOptions struct {
}

PlatformWorkloadIdentityRoleSetsClientListOptions contains the optional parameters for the PlatformWorkloadIdentityRoleSetsClient.NewListPager method.

type PlatformWorkloadIdentityRoleSetsClientListResponse ¶

type PlatformWorkloadIdentityRoleSetsClientListResponse struct {
	// PlatformWorkloadIdentityRoleSetList represents a List of role sets.
	PlatformWorkloadIdentityRoleSetList
}

PlatformWorkloadIdentityRoleSetsClientListResponse contains the response from method PlatformWorkloadIdentityRoleSetsClient.NewListPager.

type PreconfiguredNSG ¶

type PreconfiguredNSG string

PreconfiguredNSG - PreconfiguredNSG represents whether customers want to use their own NSG attached to the subnets

const (
	PreconfiguredNSGDisabled PreconfiguredNSG = "Disabled"
	PreconfiguredNSGEnabled  PreconfiguredNSG = "Enabled"
)

func PossiblePreconfiguredNSGValues ¶

func PossiblePreconfiguredNSGValues() []PreconfiguredNSG

PossiblePreconfiguredNSGValues returns the possible values for the PreconfiguredNSG const type.

type ProvisioningState ¶

type ProvisioningState string

ProvisioningState - ProvisioningState represents a provisioning state.

const (
	ProvisioningStateAdminUpdating ProvisioningState = "AdminUpdating"
	ProvisioningStateCanceled      ProvisioningState = "Canceled"
	ProvisioningStateCreating      ProvisioningState = "Creating"
	ProvisioningStateDeleting      ProvisioningState = "Deleting"
	ProvisioningStateFailed        ProvisioningState = "Failed"
	ProvisioningStateSucceeded     ProvisioningState = "Succeeded"
	ProvisioningStateUpdating      ProvisioningState = "Updating"
)

func PossibleProvisioningStateValues ¶

func PossibleProvisioningStateValues() []ProvisioningState

PossibleProvisioningStateValues returns the possible values for the ProvisioningState const type.

type ServicePrincipalProfile ¶

type ServicePrincipalProfile struct {
	// The client ID used for the cluster.
	ClientID *string

	// The client secret used for the cluster.
	ClientSecret *string
}

ServicePrincipalProfile represents a service principal profile.

func (ServicePrincipalProfile) MarshalJSON ¶

func (s ServicePrincipalProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type ServicePrincipalProfile.

func (*ServicePrincipalProfile) UnmarshalJSON ¶

func (s *ServicePrincipalProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type ServicePrincipalProfile.

type SystemData ¶

type SystemData struct {
	// The timestamp of resource creation (UTC).
	CreatedAt *time.Time

	// The identity that created the resource.
	CreatedBy *string

	// The type of identity that created the resource.
	CreatedByType *CreatedByType

	// The timestamp of resource last modification (UTC)
	LastModifiedAt *time.Time

	// The identity that last modified the resource.
	LastModifiedBy *string

	// The type of identity that last modified the resource.
	LastModifiedByType *CreatedByType
}

SystemData - Metadata pertaining to creation and last modification of the resource.

func (SystemData) MarshalJSON ¶

func (s SystemData) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type SystemData.

func (*SystemData) UnmarshalJSON ¶

func (s *SystemData) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type SystemData.

type UserAssignedIdentity ¶

type UserAssignedIdentity struct {
	// READ-ONLY; The client ID of the assigned identity.
	ClientID *string

	// READ-ONLY; The principal ID of the assigned identity.
	PrincipalID *string
}

UserAssignedIdentity - User assigned identity properties

func (UserAssignedIdentity) MarshalJSON ¶

func (u UserAssignedIdentity) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type UserAssignedIdentity.

func (*UserAssignedIdentity) UnmarshalJSON ¶

func (u *UserAssignedIdentity) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type UserAssignedIdentity.

type Visibility ¶

type Visibility string

Visibility - Visibility represents visibility.

const (
	VisibilityPrivate Visibility = "Private"
	VisibilityPublic  Visibility = "Public"
)

func PossibleVisibilityValues ¶

func PossibleVisibilityValues() []Visibility

PossibleVisibilityValues returns the possible values for the Visibility const type.

type WorkerProfile ¶

type WorkerProfile struct {
	// The number of worker VMs.
	Count *int32

	// The resource ID of an associated DiskEncryptionSet, if applicable.
	DiskEncryptionSetID *string

	// The disk size of the worker VMs.
	DiskSizeGB *int32

	// Whether master virtual machines are encrypted at host.
	EncryptionAtHost *EncryptionAtHost

	// The worker profile name.
	Name *string

	// The Azure resource ID of the worker subnet.
	SubnetID *string

	// The size of the worker VMs.
	VMSize *string
}

WorkerProfile represents a worker profile.

func (WorkerProfile) MarshalJSON ¶

func (w WorkerProfile) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaller interface for type WorkerProfile.

func (*WorkerProfile) UnmarshalJSON ¶

func (w *WorkerProfile) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaller interface for type WorkerProfile.

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
fake

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL