func NewOperator()

in pkg/operator/operator.go [76:166]


func NewOperator(ctx context.Context, operator *operator.Operator) (context.Context, *Operator) {
	azConfig, err := GetAZConfig()
	lo.Must0(err, "creating Azure config") // NOTE: we prefer this over the cleaner azConfig := lo.Must(GetAzConfig()), as when initializing the client there are helpful error messages in initializing clients and the azure config

	azClient, err := instance.CreateAZClient(ctx, azConfig)
	lo.Must0(err, "creating Azure client")
	if options.FromContext(ctx).VnetGUID == "" && options.FromContext(ctx).NetworkPluginMode == consts.NetworkPluginModeOverlay {
		vnetGUID, err := getVnetGUID(azConfig, options.FromContext(ctx).SubnetID)
		lo.Must0(err, "getting VNET GUID")
		options.FromContext(ctx).VnetGUID = vnetGUID
	}

	// These options are set similarly to those used by operator.KubernetesInterface
	inClusterConfig := lo.Must(rest.InClusterConfig())
	inClusterConfig.RateLimiter = flowcontrol.NewTokenBucketRateLimiter(float32(coreoptions.FromContext(ctx).KubeClientQPS), coreoptions.FromContext(ctx).KubeClientBurst)
	inClusterConfig.UserAgent = auth.GetUserAgentExtension()
	inClusterClient := kubernetes.NewForConfigOrDie(inClusterConfig)

	unavailableOfferingsCache := azurecache.NewUnavailableOfferings()
	pricingProvider := pricing.NewProvider(
		ctx,
		pricing.NewAPI(),
		azConfig.Location,
		operator.Elected(),
	)

	imageProvider := imagefamily.NewProvider(
		operator.KubernetesInterface,
		cache.New(azurecache.KubernetesVersionTTL,
			azurecache.DefaultCleanupInterval),
		azClient.ImageVersionsClient,
		azConfig.Location,
		azConfig.SubscriptionID,
		azClient.NodeImageVersionsClient,
	)
	imageResolver := imagefamily.NewDefaultResolver(
		operator.GetClient(),
		imageProvider,
	)
	launchTemplateProvider := launchtemplate.NewProvider(
		ctx,
		imageResolver,
		imageProvider,
		lo.Must(getCABundle(operator.GetConfig())),
		options.FromContext(ctx).ClusterEndpoint,
		azConfig.TenantID,
		azConfig.SubscriptionID,
		azConfig.ResourceGroup,
		azConfig.KubeletIdentityClientID,
		azConfig.NodeResourceGroup,
		azConfig.Location,
		options.FromContext(ctx).VnetGUID,
		options.FromContext(ctx).ProvisionMode,
	)
	instanceTypeProvider := instancetype.NewDefaultProvider(
		azConfig.Location,
		cache.New(instancetype.InstanceTypesCacheTTL, azurecache.DefaultCleanupInterval),
		azClient.SKUClient,
		pricingProvider,
		unavailableOfferingsCache,
	)
	loadBalancerProvider := loadbalancer.NewProvider(
		azClient.LoadBalancersClient,
		cache.New(loadbalancer.LoadBalancersCacheTTL, azurecache.DefaultCleanupInterval),
		azConfig.NodeResourceGroup,
	)
	instanceProvider := instance.NewDefaultProvider(
		azClient,
		instanceTypeProvider,
		launchTemplateProvider,
		loadBalancerProvider,
		unavailableOfferingsCache,
		azConfig.Location,
		azConfig.NodeResourceGroup,
		azConfig.SubscriptionID,
		options.FromContext(ctx).ProvisionMode,
	)

	return ctx, &Operator{
		Operator:                     operator,
		InClusterKubernetesInterface: inClusterClient,
		UnavailableOfferingsCache:    unavailableOfferingsCache,
		ImageProvider:                imageProvider,
		ImageResolver:                imageResolver,
		LaunchTemplateProvider:       launchTemplateProvider,
		PricingProvider:              pricingProvider,
		InstanceTypesProvider:        instanceTypeProvider,
		InstanceProvider:             instanceProvider,
		LoadBalancerProvider:         loadBalancerProvider,
	}
}