Use SDK for Go to manage ASM resources - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

O Alibaba Cloud Service Mesh (ASM) disponibiliza pacotes do SDK para Go que permitem criar, consultar, listar e excluir recursos personalizados do Istio e do ASM programaticamente, sem necessidade de usar o console ou a CLI. As APIs de recursos do Istio estão disponíveis no ASM 1,17 e versões posteriores; as APIs de recursos personalizados do ASM exigem o ASM 1,24 ou superior.

Este tópico aborda a instalação do SDK, a inicialização do cliente e operações comuns em três tipos de recursos: recursos personalizados com escopo de cluster, recursos personalizados com escopo de namespace e recursos padrão do Istio.

Pré-requisitos

Antes de começar, verifique se você tem:

Uma instância do ASM em execução (versão 1,17 ou posterior). Recursos personalizados do ASM, como ASMSwimLaneGroup e ASMLocalRateLimiter, exigem a versão 1,24 ou superior
O arquivo kubeconfig da instância do ASM salvo na máquina local (consulte Configure uma conexão abaixo)

Instale o SDK

Na raiz do projeto Go, adicione as dependências do SDK do ASM:

go get github.com/aliyun/alibabacloud-servicemesh-go-client@release-1.24.1
go get github.com/aliyun/alibabacloud-servicemesh-api@release-1.24.1

A branch release-1.24.1 corresponde à versão 1,24 do ASM. Escolha uma versão compatível com a instância atual do ASM nos repositórios:

Nota: Para instâncias do ASM anteriores à versão 1,17, use os pacotes da comunidade upstream do Istio:

Obtenha o código de exemplo

Clone o repositório de códigos de exemplo:

git clone https://github.com/AliyunContainerService/asm-labs.git

Acesse o diretório de demonstração do SDK:
```
cd clients-demo/client-go
```

Configure uma conexão

O SDK autentica na instância do ASM por meio de um arquivo kubeconfig. Para exportar a configuração de conexão:

Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.
Na página Mesh Management, clique em nome da instância do ASM. No painel de navegação à esquerda, escolha ASM Instance > Base Information.
No lado direito da página, clique em Connection e copie o conteúdo da configuração para $HOME/.kube/config.

Execute o código de exemplo

go run main.go

Saída esperada:

I0311 16:39:14.367128  650926 main.go:24] successfully create rest config
I0311 16:39:14.367296  650926 main.go:31] successfully create clientset
I0311 16:39:14.367301  650926 main.go:33] run cluster scope clients demo
I0311 16:39:14.496240  650926 main.go:60] successfully create asmswimlanegroup
I0311 16:39:14.547445  650926 main.go:67] successfully get asmswimlanegroup
I0311 16:39:14.655944  650926 main.go:74] successfully list asmswimlanegroups
I0311 16:39:14.724114  650926 main.go:81] successfully delete asmswimlanegroup
I0311 16:39:14.724124  650926 main.go:36] run namespaced scope clients demo
I0311 16:39:14.779630  650926 main.go:97] successfully create asmlocalratelimiter
I0311 16:39:14.826832  650926 main.go:104] successfully get asmlocalratelimiter
I0311 16:39:14.881993  650926 main.go:111] successfully list asmlocalratelimiters
I0311 16:39:14.947009  650926 main.go:118] successfully delete asmlocalratelimiter
I0311 16:39:14.947020  650926 main.go:39] run istio resource demo
I0311 16:39:15.002439  650926 main.go:134] successfully create virtualservice
I0311 16:39:15.052896  650926 main.go:141] successfully get virtualservice
I0311 16:39:16.258057  650926 main.go:148] successfully list virtualservices
I0311 16:39:16.323547  650926 main.go:155] successfully delete virtualservice

Entenda o código de exemplo

Cada seção abaixo explica uma parte do arquivo main.go. O exemplo demonstra operações de criação, obtenção, listagem e exclusão para três tipos de recursos usando dois clientsets distintos.

Inicialize o cliente

Carregue o arquivo kubeconfig e crie dois clientsets: um para recursos personalizados do ASM e outro para recursos do Istio.

Carregue o kubeconfig e construa a configuração REST:

kubeconfigPath := os.Getenv("HOME") + "/.kube/config"
cfg, err := clientcmd.BuildConfigFromFlags("", kubeconfigPath)
if err != nil {
  klog.Errorf("failed to create rest config, err: %+v", err)
  os.Exit(1)
}
klog.Info("successfully create rest config")

Crie o clientset do ASM para recursos personalizados como ASMSwimLaneGroup e ASMLocalRateLimiter:

clientset, err := asmversionedclient.NewForConfig(cfg)
if err != nil {
  klog.Errorf("failed to create clientset, err: %+v", err)
  os.Exit(1)
}
klog.Info("successfully create asm clientset")

Crie o clientset do Istio para recursos padrão do Istio, como VirtualService:

istioclientset, err := istioversionedclient.NewForConfig(cfg)
if err != nil {
  klog.Errorf("failed to create istio clientset, err: %+v", err)
  os.Exit(1)
}
klog.Info("successfully create istio clientset")

Gerencie recursos com escopo de cluster

Recursos com escopo de cluster existem globalmente e não estão vinculados a um namespace. Este exemplo cria, recupera, lista e exclui um ASMSwimLaneGroup usando clientset.IstioV1().ASMSwimLaneGroups():

func runClusterScopeDemo(clientset *asmversionedclient.Clientset) {
	// Deserialize the YAML definition into an ASMSwimLaneGroup object
	asmswimlanegroup := &asmv1.ASMSwimLaneGroup{}
	err := yaml.Unmarshal([]byte(swimlanegroupYaml), &asmswimlanegroup)
	if err != nil {
		klog.Errorf("failed to unmarshal yaml bytes, err: %+v", err)
		os.Exit(1)
	}

	// Create the resource in the cluster
	_, err = clientset.IstioV1().ASMSwimLaneGroups().Create(context.TODO(), asmswimlanegroup, metav1.CreateOptions{})
	if err != nil {
		klog.Errorf("failed to create asmswimlanegroup, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully create asmswimlanegroup")

	// Get the resource by name
	_, err = clientset.IstioV1().ASMSwimLaneGroups().Get(context.TODO(), asmswimlanegroup.Name, metav1.GetOptions{})
	if err != nil {
		klog.Errorf("failed to get asmswimlanegroup, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully get asmswimlanegroup")

	// List all ASMSwimLaneGroup resources
	_, err = clientset.IstioV1().ASMSwimLaneGroups().List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		klog.Errorf("failed to list asmswimlanegroups, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully list asmswimlanegroups")

	// Delete the resource by name
	err = clientset.IstioV1().ASMSwimLaneGroups().Delete(context.TODO(), asmswimlanegroup.Name, metav1.DeleteOptions{})
	if err != nil {
		klog.Errorf("failed to delete asmswimlanegroup, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully delete asmswimlanegroup")
}

Gerencie recursos com escopo de namespace

Recursos com escopo de namespace exigem um parâmetro de namespace em cada chamada de API. Este exemplo cria, recupera, lista e exclui um ASMLocalRateLimiter usando clientset.IstioV1().ASMLocalRateLimiters(namespace):

func runNamespacedScopeDemo(clientset *asmversionedclient.Clientset) {
	// Deserialize the YAML definition into an ASMLocalRateLimiter object
	asmlocalratelimiter := &asmv1.ASMLocalRateLimiter{}
	err := yaml.Unmarshal([]byte(localratelimiterYaml), &asmlocalratelimiter)
	if err != nil {
		klog.Errorf("failed to unmarshal yaml bytes, err: %+v", err)
		os.Exit(1)
	}

	// Create the resource in the specified namespace
	_, err = clientset.IstioV1().ASMLocalRateLimiters(asmlocalratelimiter.Namespace).Create(context.TODO(), asmlocalratelimiter, metav1.CreateOptions{})
	if err != nil {
		klog.Errorf("failed to create asmlocalratelimiter, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully create asmlocalratelimiter")

	// Get the resource by name within the namespace
	_, err = clientset.IstioV1().ASMLocalRateLimiters(asmlocalratelimiter.Namespace).Get(context.TODO(), asmlocalratelimiter.Name, metav1.GetOptions{})
	if err != nil {
		klog.Errorf("failed to get asmlocalratelimiter, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully get asmlocalratelimiter")

	// List all ASMLocalRateLimiter resources in the namespace
	_, err = clientset.IstioV1().ASMLocalRateLimiters(asmlocalratelimiter.Namespace).List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		klog.Errorf("failed to list asmlocalratelimiters, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully list asmlocalratelimiters")

	// Delete the resource by name
	err = clientset.IstioV1().ASMLocalRateLimiters(asmlocalratelimiter.Namespace).Delete(context.TODO(), asmlocalratelimiter.Name, metav1.DeleteOptions{})
	if err != nil {
		klog.Errorf("failed to delete asmlocalratelimiter, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully delete asmlocalratelimiter")
}

Gerencie recursos do Istio

Recursos padrão do Istio, como VirtualService, usam um clientset separado inicializado com istioversionedclient.NewForConfig. Este exemplo cria, recupera, lista e exclui um VirtualService usando clientset.NetworkingV1().VirtualServices(namespace):

func runIstioResourceDemo(clientset *istioversionedclient.Clientset) {
	// Deserialize the YAML definition into a VirtualService object
	vs := &networkingv1.VirtualService{}
	err := yaml.Unmarshal([]byte(virtualserviceYaml), &vs)
	if err != nil {
		klog.Errorf("failed to unmarshal yaml bytes, err: %+v", err)
		os.Exit(1)
	}

	// Create the VirtualService in the specified namespace
	_, err = clientset.NetworkingV1().VirtualServices(vs.Namespace).Create(context.TODO(), vs, metav1.CreateOptions{})
	if err != nil {
		klog.Errorf("failed to create virtualservice, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully create virtualservice")

	// Get the VirtualService by name
	_, err = clientset.NetworkingV1().VirtualServices(vs.Namespace).Get(context.TODO(), vs.Name, metav1.GetOptions{})
	if err != nil {
		klog.Errorf("failed to get virtualservice, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully get virtualservice")

	// List all VirtualServices in the namespace
	_, err = clientset.NetworkingV1().VirtualServices(vs.Namespace).List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		klog.Errorf("failed to list virtualservices, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully list virtualservices")

	// Delete the VirtualService by name
	err = clientset.NetworkingV1().VirtualServices(vs.Namespace).Delete(context.TODO(), vs.Name, metav1.DeleteOptions{})
	if err != nil {
		klog.Errorf("failed to delete virtualservice, err: %+v", err)
		os.Exit(1)
	}
	klog.Info("successfully delete virtualservice")
}

Comparação de tipos de recursos

Aspecto	Escopo de cluster	Escopo de namespace	Recursos do Istio
Exemplo	`ASMSwimLaneGroup`	`ASMLocalRateLimiter`	`VirtualService`
Clientset	`asmversionedclient`	`asmversionedclient`	`istioversionedclient`
Grupo de API	`IstioV1()`	`IstioV1()`	`NetworkingV1()`
Parâmetro de namespace	Não obrigatório	Obrigatório	Obrigatório
Versão mínima do ASM	1,24	1,24	1,17