Elastic Compute Service:Reduce public network exposure with PrivateLink

Use o PrivateLink para acesso entre VPCs na mesma zona

Descrição: Um serviço de rede (como um serviço web) está implantado em uma instância ECS na VPC2. Uma conexão PrivateLink entre a VPC1 e a VPC2 permite acessar o serviço a partir da VPC1 por meio de um endereço IP privado (endpoint).

: O endpoint (consumidor do serviço) e o endpoint service (provedor do serviço) devem estar na mesma zona. As zonas do endpoint devem ser um subconjunto das zonas do endpoint service. Por exemplo, se um endpoint service estiver implantado na Zona A e na Zona B, o endpoint só poderá ser criado na Zona A ou na Zona B.

Etapas principais:

1. Configuração do lado do servidor (provedor do serviço)

   1. Crie um balanceador de carga: Na VPC2, crie uma instância de SLB compatível com PrivateLink, como um CLB ou NLB voltado para rede privada. Configure um grupo de servidores de backend e um listener.

   2. Crie um endpoint service: No console do PrivateLink, crie um endpoint service e associe-o à instância de SLB criada na etapa anterior.

   3. Configure uma lista de permissões de serviço (apenas para acesso entre contas): Se a VPC1 pertencer a uma conta diferente da Alibaba Cloud, adicione o UID da conta à lista de permissões de serviço do endpoint service.

   4. Aceite a solicitação de conexão: Após o cliente iniciar uma conexão, acesse a aba Connections do endpoint service e aceite a solicitação pendente. Alternativamente, configure o serviço para aceitar conexões automaticamente.

2. Configuração do lado do cliente (consumidor do serviço)

   1. Crie um endpoint: Na VPC1, crie um endpoint e selecione o endpoint service criado no lado do servidor.

   2. Configure a rede: Selecione um vSwitch e um grupo de segurança na VPC1 para o endpoint, controlando quais recursos na VPC1 podem acessá-lo.

   3. Obtenha os detalhes do endpoint: Após a criação, um nome de domínio privado e um endereço IP são gerados.

   4. Inicie o acesso: Depois que o provedor do serviço aceitar a conexão, as aplicações na VPC1 poderão acessar o serviço na VPC2 por meio do nome de domínio ou endereço IP gerado.

Consulte Acessar serviços da Alibaba Cloud por uma rede privada.

Use o Proxy Protocol para controlar VPCs acessíveis e seus endereços IP privados

Ao fornecer serviços por meio do PrivateLink, o servidor pode identificar o endpoint ou a VPC de source de cada requisição e implementar regras de segurança adequadas. Por exemplo, é possível restringir uma conta para aceitar acesso apenas de uma VPC legítima. Mesmo que credenciais vazem, redes não autorizadas não conseguirão acessar o serviço.

Com base em Use o PrivateLink para acesso entre VPCs na mesma zona, habilite a aplicação no lado do servidor a identificar a VPC de source e implementar controle de acesso.

1. Ative o Proxy Protocol v2: Ative o Proxy Protocol v2 no listener do NLB e inscreva-se no ID da VPC e no ID do endpoint.

   # Use the Cloud Assistant CLI to enable Proxy Protocol v2 for a specified listener and subscribe to the VPC ID and endpoint ID.
   aliyun nlb UpdateListenerAttribute \
        --ListenerId lsn-xxxxxxxxxxxxxxxx \
        --ProxyProtocolEnabled true \
        --ProxyProtocolV2Config '{"Ppv2VpcIdEnabled":true,"Ppv2PrivateLinkEpIdEnabled":true}' \
        --RegionId cn-hangzhou

   --ListenerId: O ID do listener criado para o serviço web.

   --ProxyProtocolEnabled: Defina como true para ativar o Proxy Protocol. Este protocolo transmite informações de conexão do cliente no primeiro pacote após o handshake TCP. O serviço de backend deve suportar este protocolo. Consulte a Etapa 2 para obter detalhes. Caso contrário, o serviço será interrompido.

   --ProxyProtocolV2Config: Adiciona campos Type-Length-Value (TLV) definidos pela Alibaba Cloud. Este exemplo inscreve-se no ID da VPC de source e no ID do endpoint do PrivateLink. A tabela a seguir descreve como analisar o TLV.

   	Descrição/Conteúdo	Conteúdo original
   Cabeçalho do protocolo	Assinatura fixa do Proxy Protocol	0d0a0d0a000d0a515549540a
   	Versão 2, comando PROXY	21
   	TCP/IPv4	11
   	Os dados a seguir têm 84 bytes de comprimento	0054
   Informações de endereço	IP de source: 10.0.0.14	0a00000e
   	IP de destino: 10.0.0.15	0a00000f
   	Porta de source: 59074	e6c2
   	Porta de destino: 80	0050
   TLV1	Tipo 03	03
   	4 bytes	0004
   	0764b56b	0764b56b
   TLV2	Tipo e1 (tipo personalizado)	e1
   	24 bytes	0018
   	ID do endpoint do PrivateLink: ep-bp1i288487e586152d4b	0265702d6270316932383834383765353836313532643462
   TLV3	Tipo e1 (tipo personalizado)	e1
   	26 bytes	001a
   	ID da VPC: vpc-bp179qeke0wzo1mr8bxhl	017670632d627031373971656b6530777a6f316d72386278686c
   TLV4	04 (PP2_TYPE_NETNS), usado para passar o namespace de rede	04
   	6 bytes	0006
   	000000000000	000000000000

2. Se o seu serviço web utiliza Nginx, configure-o para suportar o Proxy Protocol:

   (Requer NGINX Plus R16 ou posterior, ou Nginx open source 1.13.11 ou posterior.)

   server {
       listen 80 proxy_protocol;   # Enable Proxy Protocol v1/v2.
       # Other configurations...
   }

   O Nginx analisa automaticamente o TLV do Proxy Protocol na porta 80, mas a versão padrão suporta apenas a obtenção do endereço IP a partir do TLV.

   Utilize uma extensão Lua para lidar com IDs de VPC e IDs de endpoint do PrivateLink personalizados pela Alibaba Cloud.

   O plugin Lua a seguir no nginx.conf gerencia conexões TCP, lê pacotes do socket e analisa o buffer TLV.

   Os dados analisados são armazenados no contexto da requisição. Quando uma requisição /login é feita, o código verifica o ID do endpoint do PrivateLink:

   -- Define shared memory before the http block.
   lua_shared_dict tlv_cache 10m;
   
   stream {
     server {
       listen 80;  # Do not enable proxy_protocol. Let the Lua code below handle it.
       preread_by_lua_block {
          -- 1. Try to read the fixed 16-byte protocol header.
          local sock = ngx.req.socket(true)
          local header, err = sock:receive(16)
   
          if not header then
             ngx.log(ngx.ERR, "failed to receive proxy protocol header: ", err)
             return
          end
   
          -- 2. Check the protocol signature (12 bytes).
          if string.sub(header, 1, 12) ~= "\x0D\x0A\x0D\x0A\x00\x0D\x0A\x51\x55\x49\x54\x0A" then
              -- If it is not the Proxy Protocol, put the read data back into the buffer to avoid corrupting the original request.
               sock:setreused(header)
                     return
         end
   
         -- 3. Parse the rest of the protocol header.
         local ver_cmd = string.byte(header, 13) -- Version and command
         local family = string.byte(header, 14) -- Address family and protocol
         local len = string.byte(header, 15) * 256 + string.byte(header, 16) -- Total length of the variable part
         if len == 0 then
            -- No address or TLV information. Return directly.
            return
         end
   
         -- 4. Read the variable-length part (contains address and TLV).
         local variable_part, err = sock:receive(len)
         if not variable_part or #variable_part < len then
            ngx.log(ngx.ERR, "failed to read variable part (address + tlvs): ", err)
            return
         end
   
         -- 5. Determine the length of the address information based on the address family.
         local addr_len = 0
         local protocol = family & 0x0F
         local address_family = family >> 4
   
         if address_family == 1 then -- AF_INET (IPv4)
             addr_len = 12
         elseif address_family == 2 then -- AF_INET6 (IPv6)
             addr_len = 36
         elseif address_family == 3 then -- AF_UNIX
             addr_len = 216
         end
   
         -- 6. Separate the address information and TLV data.
         local address_block = string.sub(variable_part, 1, addr_len) -- You can parse the address information if needed.
         local tlv_string = string.sub(variable_part, addr_len + 1)
   
         -- 7. Parse the TLV data.
         local tlvs = {}
         local pos = 1
         while pos <= #tlv_string do
             -- Make sure there are at least 3 bytes (Type, Length).
             if pos + 2 > #tlv_string then
                 ngx.log(ngx.ERR, "malformed TLV data: not enough bytes for type and length")
                 break
             end
   
             local tlv_type = string.byte(tlv_string, pos)
             local tlv_length = string.byte(tlv_string, pos + 1) * 256 + string.byte(tlv_string, pos + 2)
         
             -- Make sure the length of the value does not exceed the boundary.
             if pos + 2 + tlv_length > #tlv_string then
                 ngx.log(ngx.ERR, "malformed TLV data: length exceeds available data")
                 break
             end
         
             local tlv_value = string.sub(tlv_string, pos + 3, pos + 2 + tlv_length)
                         
             table.insert(tlvs, {
                 type = tlv_type,
                 length = tlv_length,
                 -- Encode the binary value in Base64 for easy storage and viewing.
                 value = ngx.encode_base64(tlv_value) 
              })
              pos = pos + 3 + tlv_length
        end
   
        -- 8. Cache the parsed TLV in shared memory.
        if #tlvs > 0 then
           local cjson = require "cjson"
           local tlv_cache = ngx.shared.tlv_cache
           -- Use the client IP address as the key to store the TLV data.
           local client_ip = ngx.var.remote_addr
           local tlv_json = cjson.encode(tlvs)
           tlv_cache:set(client_ip, tlv_json, 60)  -- Cache for 60 seconds.
           -- Optional: Also store in ngx.ctx for the stream layer to use.
           ngx.ctx.proxy_protocol_tlvs = tlvs
        end
       }
       proxy_pass localhost:8080;   # Pass subsequent HTTP requests to the HTTP server for processing.
     }
   }
   
   http {
       server {
           listen 8080;
   
           # Dedicated location to handle /login requests.
           location /login {
               access_by_lua_block {
                   local cjson = require "cjson"
                   local tlv_cache = ngx.shared.tlv_cache
                   -- Get TLV data from shared memory.
                   local client_ip = ngx.var.remote_addr
                   local tlv_json = tlv_cache:get(client_ip)
                   if not tlv_json then
                      ngx.log(ngx.ERR, "No TLV data found for client: ", client_ip)
                      return ngx.exit(ngx.HTTP_FORBIDDEN)
                   end
                   local tlvs = cjson.decode(tlv_json)
                   -- Extract the value of the second TLV (PrivateLink endpoint ID).
                   local privateLinkEndId = nil
                   if tlvs[2] then
                      privateLinkEndId = tlvs[2].value  -- Base64-encoded value.
                   end
                   -- Define the expected endpoint ID (Base64-encoded).
                   local expected_value = "ZXAtYnAxaTI4ODQ4N2U1ODYxNTJkNGI="  -- Example value. Modify it as needed.
                   -- Verify the endpoint ID.
                   if privateLinkEndId ~= expected_value then
                      ngx.log(ngx.ERR, "Access to /login denied: TLV value mismatch. Expected '", expected_value, "', got '", tostring(privateLinkEndId), "'")
                      return ngx.exit(ngx.HTTP_FORBIDDEN)
                   end
                   -- If the verification is successful, the request continues to be processed.
               }
               proxy_pass http://your_python_backend;
           }
   
           # Handle all other requests.
           location / {
               proxy_pass http://your_python_backend;
           }
       }
   
       # Your Python backend service upstream definition.
       upstream your_python_backend {
           server 127.0.0.1:5000; # Assume your backend program runs on port 5000.
       }
   }