Implantação e conexão de gateways de borda do Service Interconnect usando a CLI

Editar on-line

Use a palmctl CLI para implantar seus Red Hat® Service Interconnect® gateways em IBM® Hybrid Cloud Mesh (Mesh) e conecte os gateways usando uma conexão remota.

Pré-requisitos

  1. Instale um agente Open Horizon para gerenciar o gateway. Consulte Instalação de um agente Open Horizon.
  2. Instale a Mesh CLI. Consulte Instalação da CLI.
  3. Crie ou identifique um segmento Mesh de rede que contenha o namespace gerenciado. Para obter mais informações sobre como criar um segmento de rede, consulte Criando segmentos de rede em malha usando a CLI.
  4. Crie ou identifique um namespace Mesh gerenciado que represente o namespace Kubernetes onde você deseja implantar o gateway.
  5. Se você deseja especificar a versão do Red Hat Service Interconnect que será instalada ao implantar o gateway, execute as seguintes etapas:
    1. Veja as versões compatíveis executando o seguinte comando:
      palmctl get rhsi-versions
    2. Ao implementar o gateway, inclua o seguinte campo com a versão apropriada:
      "intended_version": "<rhsi_version>"
    Se uma versão não for especificada, será instalada a última versão compatível. Consulte Plataformas e softwares compatíveis.
Ativação do acesso de clientes externos:

Para permitir que os aplicativos executados em ambientes que não sejam o Kubernetes acessem os serviços nesse gateway, você deve ativar o acesso de cliente externo ao implantar o gateway. Por padrão, o acesso de clientes externos está desativado.

Para obter mais informações, consulte Configurando o acesso de clientes externos usando a CLI Mesh.

Implantar o gateway

Para implantar um gateway usando a CLI ' palmctl, siga estas etapas:
  1. Configure o gateway usando o comando ' palmctl patch. Por exemplo, execute um comando como este:
    cat << EOF | palmctl patch gateway --name <gateway-name> -f -
intended_compute_profile: <intended_compute_profile_type>
site_configuration: '{
  "ingress": "<ingress>",
  "ingress_host": "<ingress_host>",
  "router_ingress_host": "<router_ingress_host>",
  "controller_ingress_host": "<controller_ingress_host>",
  "ingress_annotations": "<ingress_annotations>",
  "flow_collector": true/false,
  "console": true/false,
  "router_console": true/false,
  "router_cpu": "<router_cpu>m",
  "router_cpu_limit": "<router_cpu_limit>m",
  "router_memory": "<router_memory>Mi",
  "router_memory_limit": "<router_memory_limit>Mi",
  "run_as_user": <run_as_user>,
  "controller_pod_annotation": "<controller_pod_annotation>",
  "site_name": "<site_name>",
  "router_mode": "interior",
  "labels": "<labels>",
  "router_logging": "<router_logging>",
  "create_network_policy": false,
  "enable_rest_api": true/false,
  "annotations": "<annotations>",
  "router_service_annotations": "<router_service_annotations>",
  "router_pod_annotations": "<router_pod_annotations>",
  "enable_service_sync": true,
  "routers": "<routers_count>",
  "router_load_balancer_ip": "<router_load_balancer_ip>",
  "router_data_connection_count": "<router_data_connection_count>",
  "enable_skupper_events": true/false
}'
EOF
    Os parâmetros na seção de configuração do site são opcionais. Para alguns dos parâmetros, os seguintes valores padrão se aplicam se você não fornecer um valor.
    router-mode: interior
router-logging: Information
create-network-policy: False
enable-service-sync: true
routers: 0
  2. Crie o namespace no qual você deseja implantar o gateway, se ainda não houver um. Por exemplo, execute um comando como este:
    cat << EOM | palmctl create namespace --cloud-name <cloud-name> --cluster-name <cluster-name> -f -
name: <namespace-name>
network_segment_id: <network_segment_id>
EOM
  3. Defina a ID do segmento de rede e a ID do gateway para o namespace usando o comando " palmctl patch. Por exemplo, execute um comando como este:
    cat << EOM | palmctl patch namespace --cloud-name <cloud-name> --cluster-name <cluster-name> --name <namespace-name> -f -
network_segment_id: <network_segment_id>
gateway_id: <gateway_id>
EOM
    O gateway é implementado com os parâmetros que você especificou na etapa 1.
Notas:
  • <gateway-name> deve ser exclusivo.
  • Os valores disponíveis para o " intended_compute_profile são " small, " medium, " large e " custom. Para " custom, o usuário pode selecionar " router_cpu, " router_cpu_limit, " router_memory ou " router_memory_limit para fornecer valores personalizados. Esse campo determina o máximo de recursos de CPU e de memória que o gateway pode utilizar Depois que o gateway é implementado, não é possível modificar essas configurações
  • O atributo ingress no campo site_configuration determina o controlador de ingresso usado quando o gateway é implementado. Para obter mais informações sobre as configurações, consulte o documento de ajuda Inicializar o Skupper.
  • Todos os parâmetros de configuração do site são opcionais.
  • Para obter mais informações sobre as configurações do roteador, consulte o documento de ajuda Inicializar Skupper. Visualize as informações sobre as opções ' site-name, ' router-mode, ' router-logging, ' annotations, ' router-service-annotations, ' router-pod-annotations, ' routers, ' router-data-connection-count, ' router-load-balancer-ip, ' create-network-policy, ' enable-service-sync e ' labels.
  • Você só pode atualizar os parâmetros de configuração do site quando o life_cycle_state parâmetro estiver definido como gwnot-deployed-. O life_cycle_state parâmetro é uma propriedade da borda do Service Interconnect.

Implante o gateway usando arquivos YAML ou JSON

Você pode aplicar as configurações do gateway usando um arquivo YAML ou JSON. O uso desses arquivos permite que os usuários os reutilizem posteriormente. Você também pode usar ferramentas como yq ou jq para verificar a integridade do YAML ou JSON.

  1. Crie um arquivo YAML para armazenar seus parâmetros de entrada. Por exemplo, crie um arquivo chamado " gw_site_config_params.yaml e adicione os seguintes parâmetros de entrada:

    intended_compute_profile: <intended_compute_profile_type>
site_configuration: '{
  "ingress": "<ingress>",
  "ingress_host": "<ingress_host>",
  "router_ingress_host": "<router_ingress_host>",
  "controller_ingress_host": "<controller_ingress_host>",
  "ingress_annotations": "<ingress_annotations>",
  "flow_collector": true/false,
  "console": true/false,
  "router_console": true/false,
  "router_cpu": "<router_cpu>m",
  "router_cpu_limit": "<router_cpu_limit>m",
  "router_memory": "<router_memory>Mi",
  "router_memory_limit": "<router_memory_limit>Mi",
  "run_as_user": <run_as_user>,
  "controller_pod_annotation": "<controller_pod_annotation>",
  "site_name": "<site_name>",
  "router_mode": "interior",
  "labels": "<labels>",
  "router_logging": "<router_logging>",
  "create_network_policy": false,
  "enable_rest_api": true/false,
  "annotations": "<annotations>",
  "router_service_annotations": "<router_service_annotations>",
  "router_pod_annotations": "<router_pod_annotations>",
  "enable_service_sync": true,
  "routers": "<routers_count>",
  "router_load_balancer_ip": "<router_load_balancer_ip>",
  "router_data_connection_count": "<router_data_connection_count>",
  "enable_skupper_events": true/false
}'
EOF
  2. Crie um arquivo JSON para armazenar seu parâmetro de entrada. Por exemplo, criei um arquivo chamado " siteconfig.json e os seguintes parâmetros de entrada:
    {   "Intended_compute_profile": "custom",   "site_configuration": "{ \"ingress\":
      \"route\", \"ingress_host\": \"ingress.host.name\", \"router_ingress_host\":
      \"router.ingress.host.name\", \"controller_ingress_host\":
      \"controller.ingress.host.name\", \"ingress_annotations\":
      \"ingress_annotations6=ingress_annotations61\", \"flow_collector\": true, \"console\":
      false, \"router_console\": false, \"router_cpu\": \"100m\", \"router_cpu_limit\":
      \"1000m\", \"router_memory\": \"100Mi\", \"router_memory_limit\": \"1000Mi\",
      \"run_as_user\": 1000, \"controller_pod_annotation\":
      \"skupper.io/component=controller\", \"site_name\": \"site2266\", \"router_mode\":
      \"interior\", \"labels\": \"test2266\", \"router_logging\": \"info\",
      \"create_network_policy\": false, \"enable_rest_api\": false, \"annotations\":
      \"annotations=annotations2266\", \"router_service_annotations\":
      \"routerservice=value2266\", \"router_pod_annotations\": \"routerpod=value1\",
      \"enable_service_sync\": false, \"routers\": \"6\", \"router_load_balancer_ip\":
      \"6.5.5.5\", \"router_data_connection_count\": \"6\", \"enable_skupper_events\": false
      }" }

  3. Aplique as configurações do gateway usando um arquivo YAML ou JSON. Por exemplo, execute um comando como este:

    palmctl patch gateway --name <gw-name> -f gw_site_config_params.yaml
    palmctl patch gateway --name <gw-name> -f siteconfig.json
    Notas:
    • <gateway-name> deve ser exclusivo.
    • Os valores disponíveis para o " intended_compute_profile são " small, " medium, " large e " custom. Para " custom, o usuário pode selecionar " router_cpu, " router_cpu_limit, " router_memory ou " router_memory_limit para fornecer valores personalizados. Esse campo determina o máximo de recursos de CPU e de memória que o gateway pode utilizar Depois que o gateway é implementado, não é possível modificar essas configurações
    • O atributo ingress no campo site_configuration determina o controlador de ingresso usado quando o gateway é implementado. Para obter mais informações sobre as configurações, consulte o documento de ajuda Inicializar o Skupper.
    • Todos os parâmetros de configuração do site são opcionais.
    • Para obter mais informações sobre as configurações do roteador, consulte o documento de ajuda Inicializar Skupper. Visualize as informações sobre as opções ' site-name, ' router-mode, ' router-logging, ' annotations, ' router-service-annotations, ' router-pod-annotations, ' routers, ' router-data-connection-count, ' router-load-balancer-ip, ' create-network-policy, ' enable-service-sync e ' labels.
    • Você só pode atualizar os parâmetros de configuração do site quando o life_cycle_state parâmetro estiver definido como gwnot-deployed-. O life_cycle_state parâmetro é uma propriedade da borda do Service Interconnect.

Conectar dois gateways

Para conectar dois gateways de borda do Service Interconnect, é necessário criar uma Mesh conexão remota. Os gateways que você está conectando devem estar associados ao mesmo segmento de rede.

Dica: Uma Mesh conexão remota é unidirecional e possui um gateway de origem e um gateway de destino. No entanto, os gateways de borda Service Interconnect são bidirecionais. Você não precisa criar uma Mesh conexão remota em ambas as direções.

Para criar uma conexão remota, é necessário o nome do gateway de origem e o ID do gateway de destino

Conclua as etapas a seguir:
  1. Obtenha o ID do gateway de destino:
    palmctl get gateways --cloud-name <cloud-name>
    • <cloud-name> é o nome da Mesh nuvem onde os gateways são definidos.
    • O ID do gateway de destino é mostrado no campo resource_id na saída..
  2. Crie a conexão remota:
    cat << EOM | palmctl create remoteconnection --gateway-name=<gateway-name> -f -
name: <connection-name>
remote_gw_id: <destination-gateway-resource-id>
EOM
    • <gateway-name> é o nome do gateway de origem..
    • <connection-name> deve ser exclusivo.
    Para estabelecer a comunicação entre os gateways, Mesh solicita um link que é secreto do gateway de destino e o implanta no gateway de origem.
    Dica: A saída dos comandos palmctl get remoteconnectionpalmctl get remoteconnections e contém um secure_health_status valor. Use este valor para determinar se uma conexão remota segura é up, down, ou initializing. Ignore o health_status atributo.

O que fazer a seguir

Crie uma política Mesh de conexão para que as solicitações de serviço possam fluir pelo gateway de borda do Service Interconnect. Consulte Conectando aplicativos usando políticas com a CLI Mesh.