Como instalar o Instant API no Kubernetes

Oz Instant API é uma implantação sem estado do Oz API: executa análises de Liveness e correspondência facial e retorna resultados imediatamente, sem armazenar qualquer mídia ou resultados. Este guia cobre a instalação dele no Kubernetes via o Helm chart.

O exemplo abaixo é baseado na versão 1.0.2 do chart. No entanto, este é um exemplo ilustrativo, e recomendamos usar a versão mais recente do chart.

Pré-requisitos

Antes de começar: solicite estes itens ao seu representante da Oz.

• credenciais do DockerHub – para baixar a imagem do Instant API (usado na etapa 2 de Preparação).).

• chave de licença – necessária para executar o Instant API (etapa 3 de Preparação).).

• tag da imagem – a versão da imagem da aplicação a ser implantada (usada em seu arquivo values ).

Se você planejar usar OzCapsula, também será necessário gerar um par de chaves JWT (etapa 4 de Preparação).).

Kubernetes 1.23+ – o chart usa autoscaling/v2 (HPA com políticas de comportamento, GA em 1.23), networking.k8s.io/v1 (Ingress, GA em 1.19), e policy/v1 (PDB, GA em 1.21). Clusters executando 1.21–1.22 são parcialmente suportados por fallback automático para autoscaling/v2beta2 e policy/v1beta1.

Antes da instalação, verifique se os seguintes componentes estão em execução no seu cluster:

• Controlador Ingress (um dos seguintes, ao usar a API Ingress):

  • F5 NGINX Ingress Controller >= 3.0 (recomendado, IngressClass: f5-nginx).

  • ingress-nginx >= 1.0 (legado, em descontinuação, IngressClass: nginx).

• CRDs do Gateway API >= 1.0 e um controlador compatível (ex.: Istio >= 1.20, Envoy Gateway, Cilium) – ao usar a Gateway API em vez de Ingress. O chart cria gateway.networking.k8s.io/v1 recursos (Gateway, HTTPRoute).

• cert-manager >= 1.0 com um ClusterIssuer (para certificados TLS). Para TLS da Gateway API, é necessário cert-manager >= 1.5 com --feature-gates=ExperimentalGatewayAPISupport=true.

• metrics-server >= 0.5 (necessário para autoscaling com HPA).

• cluster-autoscaler (opcional, para escalonamento automático de nós).

• KEDA >= 2.0 (opcional, alternativa ao HPA padrão; o chart usa keda.sh/v1alpha1 API ScaledObject).

• Prometheus Operator (kube-prometheus-stack) >= 0.44 (opcional, para monitoring.coreos.com/v1 suporte a ServiceMonitor).

Preparação).

1. Crie um namespace

kubectl create namespace api-instant

2. Crie secret de pull da imagem

kubectl -n api-instant create secret docker-registry oz-dockerhub-creds \
  --docker-server=docker.io \
  --docker-username=<USERNAME> \
  --docker-password='<PASSWORD>' \
  --docker-email=<EMAIL>

Como alternativa, se você já tiver uma .dockerconfigjson string base64 pré-codificada (ex.: fornecida pelo Suporte da Oz), use uma das opções:

Opção A: decodificar inline (Linux/macOS)

kubectl -n api-instant create secret generic oz-dockerhub-creds \
  --type=kubernetes.io/dockerconfigjson \
  --from-literal=.dockerconfigjson="$(echo '<BASE64_ENCODED_DOCKERCONFIGJSON>' | base64 -d)"

Opção B: salve primeiro em arquivo e depois crie a partir do arquivo

echo '<BASE64_ENCODED_DOCKERCONFIGJSON>' | base64 -d > dockerconfig.json
kubectl -n api-instant create secret generic oz-dockerhub-creds \
  --type=kubernetes.io/dockerconfigjson \
  --from-file=.dockerconfigjson=dockerconfig.json
rm dockerconfig.json

Opção C: aplique um manifesto Secret com a string base64 no campo data

apiVersion: v1
kind: Secret
metadata:
  name: oz-dockerhub-creds
  namespace: api-instant
type: kubernetes.io/dockerconfigjson
data:
  .dockerconfigjson: <BASE64_ENCODED_DOCKERCONFIGJSON>

Depois:

kubectl apply -f secret.yaml

O valor abaixo de .dockerconfigjson é uma string JSON codificada em base64 no formato {"auths":{"<https://index.docker.io/v1/>":{"username":"...","password":"...","auth":"..."}}}. Entre em contato com o Suporte da Oz para obter as credenciais. O nome do secret deve corresponder a imagePull.secret em seus values (padrão: oz-dockerhub-creds).

3. Obtenha uma chave de licença

Entre em contato Suporte da Oz para obter sua chave de licença.

4. Crie secret JWT (opcional)

O Instant API, no caso de uso do OzCapsula, requer um par de chaves JWT para tokens de sessão. Gere as chaves e crie o secret:

openssl ecparam -name secp384r1 -genkey -noout | openssl pkcs8 -topk8 -nocrypt -out jwt.key
openssl ec -in jwt.key -pubout -out jwt.pub

kubectl -n api-instant create secret generic api-instant-jwt \
  --from-file=jwt.pub=./jwt.pub \
  --from-file=jwt.key=./jwt.key

O nome do secret deve corresponder a api.jwt.secretName em seus values (padrão: "").

Instalação

1. Adicione o repositório Helm

helm repo add ozchartmuseum https://chartmuseum.infra.ozforensics.ai helm repo update

2. Aplique a configuração básica

Crie um my-values.yaml arquivo:

my-values.yaml

api:
  hostname: api-instant.example.com
  licenseKey: "YOUR_LICENSE_KEY"
  image:
    repository: ozforensics/oz-api-instant
    tag: "6.6-ask-oz-support-team"

Instale o chart:

helm install oz-api-instant ozchartmuseum/oz-api-instant \
  -n api-instant \
  -f my-values.yaml

3. Verifique a instalação

Para verificar que a API está ativa e respondendo, chame GET {{host}}/api/healthcheck.

Para confirmar que ela processa solicitações de verificação, execute uma análise no Instant API implantado.

Atualização

helm repo update
helm upgrade oz-api-instant ozchartmuseum/oz-api-instant \
  -n api-instant \
  -f my-values.yaml

Configuração principal

Somente os parâmetros marcados como Obrigatórios devem ser definidos (eles aparecem na Configuração básica acima). Todos os outros parâmetros são opcionais – você só precisa saber que eles existem e pode sobrescrevê-los se necessário.

Parâmetro	Descrição	Padrão
imagePull.secret	Nome do secret de pull da imagem	oz-dockerhub-creds
imagePull.policy	Política de pull da imagem	IfNotPresent
affinity	Regras globais de afinidade de pods (nodeAffinity, podAffinity, podAntiAffinity)	{}
nodeSelector	Restrições globais de seletor de nós	{}
tolerations	Tolerations globais	[]
api.hostname	Obrigatório. Hostname público para o Instant API	somehost.example.local
api.additionalHostnames	Hostnames adicionais (ex.: aliases de CDN); adicionados às regras de Ingress e aos listeners do Gateway	[]
api.licenseKey	Obrigatório. Chave de licença para o Instant API (do Suporte da Oz)	""
api.extraEnvs	Variáveis de ambiente adicionais (pares chave-valor). Armazenadas em um ConfigMap – não coloque segredos aqui.	{NUM_WORKERS: "16", ...}
api.extraEnvVarsSecret	Nome de um Secret existente cujas chaves são injetadas como variáveis de ambiente (via envFrom.secretRef). Use para valores sensíveis, como credenciais do S3.	""
api.image.tag	Obrigatório. Tag da imagem da aplicação (entre em contato com o Suporte da Oz)	""
api.resources	requests/limits de CPU e memória	requests/limits: 15 CPU, 28Gi RAM
api.autoscaling.hpa.enabled	Ativar HPA	true
api.autoscaling.keda.enabled	Ativar KEDA ScaledObject	false
api.ingress.enabled	Criar recurso Ingress	true
api.ingress.className	classe do Ingress	nginx
api.ingress.annotations	anotações do Ingress (proxy, CORS, etc.)	{}
api.ingress.tls.enabled	Ativar TLS	true
api.ingress.tls.clusterIssuer	ClusterIssuer do cert-manager	letsencrypt-production
api.gateway.enabled	Criar recursos da Gateway API (mutuamente exclusivo com api.ingress)	false
api.gateway.className	nome da classe do Gateway	istio
api.gateway.annotations	anotações do Gateway	{}
api.gateway.tls.enabled	Ativar TLS no Gateway	true
api.gateway.tls.clusterIssuer	ClusterIssuer do cert-manager para o Gateway	letsencrypt-production-dns
api.proxy.enabled	Ativar proxy HTTP	false
api.proxy.url	URL do proxy	<http://proxy.local:3128>
api.proxy.auth.existingSecret	Nome de um Secret existente com all_proxy a chave contendo a URL completa do proxy. Se definido, login/senha são ignorados.	""
api.proxy.auth.login	Nome de usuário do proxy (usado quando existingSecret não está definido)	""
api.proxy.auth.password	Senha do proxy – caracteres especiais são codificados automaticamente com percent-encoding (usado quando existingSecret não está definido)	""
api.serviceMonitor.enabled	Criar ServiceMonitor do Prometheus	true

Para a lista completa de parâmetros, consulte values.yaml.

Gerenciamento de tráfego

Este chart suporta duas maneiras de rotear tráfego externo para o Instant API: API Ingress do K8s e API Gateway do K8s. Elas são mutuamente exclusivas – habilite apenas uma por vez.

Importante: Qualquer configuração de gerenciamento de tráfego (balanceamento de carga, tentativas, pooling de conexões, CORS, etc.) deve ser validada com testes de carga que reflitam a configuração escolhida e o perfil real de tráfego do cliente.

Você pode usar qualquer controlador que implemente a API K8s escolhida. Os exemplos abaixo mostram as opções mais comuns.

Opção 1: API Ingress do K8s (padrão)

Defina api.ingress.enabled: true (padrão) e api.gateway.enabled: false.

O chart cria um recurso Ingress Você precisa de um controlador Ingress instalado no seu cluster. Defina api.ingress.className para corresponder à IngressClass do seu controlador.

api.ingress.annotations está vazio por padrão. Adicione as anotações de que seu controlador precisa.

Controlador Ingress-NGINX – exemplo de configuração

Observação: O Ingress-NGINX projeto está em descontinuação. Considere migrar para o F5 NGINX Ingress Controller.

Ingress-NGINX

api:
  ingress:
    className: nginx
    annotations:
      nginx.ingress.kubernetes.io/proxy-body-size: "150m"
      nginx.ingress.kubernetes.io/load-balance: "least_conn"
      nginx.ingress.kubernetes.io/upstream-keepalive-connections: "0"
      nginx.ingress.kubernetes.io/proxy-next-upstream: "error timeout http_500"
      nginx.ingress.kubernetes.io/proxy-next-upstream-timeout: "10"
      nginx.ingress.kubernetes.io/proxy-next-upstream-tries: "2"
      nginx.ingress.kubernetes.io/enable-cors: "true"
      nginx.ingress.kubernetes.io/cors-allow-origin: "*"
      nginx.ingress.kubernetes.io/cors-allow-methods: "GET, POST, OPTIONS, PATCH, DELETE"
      nginx.ingress.kubernetes.io/cors-allow-headers: "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,x-forensic-access-token"

Controlador F5 NGINX Ingress – exemplo de configuração

F5 NGINX

api:
  ingress:
    className: f5-nginx
    annotations:
      nginx.org/client-max-body-size: "150m"
      nginx.org/lb-method: "least_conn"
      nginx.org/keepalive: "0"
      nginx.org/proxy-next-upstream: "error timeout http_500"
      nginx.org/proxy-next-upstream-timeout: "10"
      nginx.org/proxy-next-upstream-tries: "2"
      nginx.org/location-snippets: |
        add_header Access-Control-Allow-Origin "*" always;
        add_header Access-Control-Allow-Methods "GET, POST, OPTIONS, PATCH, DELETE" always;
        add_header Access-Control-Allow-Headers "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,x-forensic-access-token" always;

O F5 NGINX Ingress Controller não possui anotações dedicadas para CORS. Use nginx.org/location-snippets com add_header diretivas em vez disso.

Consulte a documentação de anotações do F5 NGINX IC e o guia de migração do ingress-nginx.

Outros controladores Ingress

Qualquer controlador que implemente a API Ingress do Kubernetes funcionará. Defina api.ingress.className para a IngressClass do seu controlador e forneça as anotações apropriadas.

Opção 2: Gateway API

Defina api.ingress.enabled: false e api.gateway.enabled: true.

O chart cria um recurso Gateway e HTTPRoute Você precisa de um controlador que implemente a Gateway API do Kubernetes (ex.: Istio, Envoy Gateway, Cilium). Defina api.gateway.className para corresponder à sua GatewayClass.

Istio – exemplo de configuração

Pré-requisitos:

• Istio >= 1.20 com CRDs do Gateway API instalado

• cert-manager >= 1.5 com --feature-gates=ExperimentalGatewayAPISupport=true

Istio

api:
  ingress:
    enabled: false
  gateway:
    enabled: true
    className: istio
    tls:
      clusterIssuer: letsencrypt-production-dns
      secretName: api-gateway-tls-certs
    annotations:
      # Anotações do balanceador de carga na nuvem (exemplo de AWS NLB)
      service.beta.kubernetes.io/aws-load-balancer-attributes: load_balancing.cross_zone.enabled=true
      service.beta.kubernetes.io/aws-load-balancer-proxy-protocol: '*'
      service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing

O chart cria Gateway e HTTPRoute recursos. Políticas de tráfego como balanceamento de carga, tentativas e CORS não são gerenciadas por este chart ao usar a Gateway API. Configure-as com CRDs do Istio aplicadas junto com o release do Helm.

Política de tráfego	Recurso do Istio	Configuração
Balanceamento de carga	DestinationRule	loadBalancer.simple: LEAST_REQUEST
Agrupamento de conexões	DestinationRule	connectionPool.http.maxRequestsPerConnection
Detecção de outliers	DestinationRule	outlierDetection (expulsar endpoints não saudáveis em 5xx)
Tentativas	EnvoyFilter	Nível de rota retryPolicy
CORS	EnvoyFilter	Filtro CORS do Envoy (typedPerFilterConfig)

Istio – balanceamento de carga, agrupamento de conexões e detecção de outliers

Crie um DestinationRule direcionado ao serviço Instant API (substitua <release-name> pelo nome do seu release do Helm, por ex. oz-api-instant):

DestinationRule

apiVersion: networking.istio.io/v1
kind: DestinationRule
metadata:
  name: api-instant-traffic-policy
  namespace: api-instant
spec:
  host: <release-name>-api.api-instant.svc.cluster.local
  trafficPolicy:
    loadBalancer:
      simple: LEAST_REQUEST
    connectionPool:
      http:
        maxRequestsPerConnection: 1            # desative keepalive entre o gateway e os pods upstream
    outlierDetection:
      consecutive5xxErrors: 1                  # expulse o endpoint no primeiro 5xx
      interval: 10s
      baseEjectionTime: 30s

Por padrão, LEAST_REQUEST seleciona o endpoint menos carregado dentre 2 candidatos aleatórios. Para uma distribuição mais uniforme entre os pods (especialmente útil com cargas pesadas de verificação de liveness), crie um EnvoyFilter para aumentar o tamanho do conjunto de candidatos:

EnvoyFilter para o tamanho do conjunto de candidatos

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: api-instant-least-request-lb-config
  namespace: api-instant
spec:
  workloadSelector:
    labels:
      gateway.networking.k8s.io/gateway-name: <release-name>-gateway-api
  configPatches:
  - applyTo: CLUSTER
    match:
      context: GATEWAY
      cluster:
        name: outbound|8080||<release-name>-api.api-instant.svc.cluster.local
    patch:
      operation: MERGE
      valor:
        lb_policy: LEAST_REQUEST
        least_request_lb_config:
          choice_count: 5

Maior choice_count valores melhoram a distribuição de carga, mas adicionam uma pequena sobrecarga por requisição. Um valor de 5 é um bom ponto de partida para clusters com 5+ pods.

Como alternativa, no Istio >= 1.22 (Envoy >= 1.30) é possível usar o FULL_SCAN método de seleção, que verifica todos os endpoints e escolhe o que tiver menos requisições ativas (empates são resolvidos via amostragem por reservatório). Isso garante a escolha ótima, mas custa O(n) por requisição, portanto é mais adequado para implantações com um pequeno número de pods ou baixo RPS:

EnvoyFilter com FULL_SCAN

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: api-instant-least-request-lb-full-scan
  namespace: api-instant
spec:
  workloadSelector:
    labels:
      gateway.networking.k8s.io/gateway-name: <release-name>-gateway-api
  configPatches:
  - applyTo: CLUSTER
    match:
      context: GATEWAY
      cluster:
        name: outbound|8080||<release-name>-api.api-instant.svc.cluster.local
    patch:
      operation: MERGE
      valor:
        load_balancing_policy:
          policies:
          - typed_extension_config:
              name: envoy.load_balancing_policies.least_request
              typed_config:
                "@type": type.googleapis.com/envoy.extensions.load_balancing_policies.least_request.v3.LeastRequest
                selection_method: FULL_SCAN

Quando load_balancing_policy está definido, ele tem precedência sobre o legado lb_policy / least_request_lb_config campos. Use uma abordagem ou a outra, não ambas.

Istio – tentativas

Crie um EnvoyFilter para adicionar uma política de tentativas no nível da rota:

EnvoyFilter para política de tentativas

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: api-instant-retries
  namespace: api-instant
spec:
  workloadSelector:
    labels:
      gateway.networking.k8s.io/gateway-name: <release-name>-gateway-api
  configPatches:
  - applyTo: HTTP_ROUTE
    match:
      context: GATEWAY
    patch:
      operation: MERGE
      valor:
        route:
          retryPolicy:
            retryOn: "connect-failure,reset,5xx"
            numRetries: 2

Istio – CORS

Crie um EnvoyFilter para configurar os cabeçalhos CORS:

EnvoyFilter para CORS

apiVersion: networking.istio.io/v1alpha3
kind: EnvoyFilter
metadata:
  name: api-instant-cors
  namespace: api-instant
spec:
  workloadSelector:
    labels:
      gateway.networking.k8s.io/gateway-name: <release-name>-gateway-api
  configPatches:
  - applyTo: HTTP_ROUTE
    match:
      context: GATEWAY
    patch:
      operation: MERGE
      valor:
        typedPerFilterConfig:
          envoy.filters.http.cors:
            "@type": type.googleapis.com/envoy.extensions.filters.http.cors.v3.CorsPolicy
            filterEnabled:
              defaultValue:
                numerator: 100
                denominator: HUNDRED
            allowOriginStringMatch:
            - safeRegex:
                regex: ".*"
            allowMethods: "GET, POST, OPTIONS, PATCH, DELETE"
            allowHeaders: "DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,x-forensic-access-token"

Substitua <release-name> pelo nome do seu release do Helm (por ex. oz-api-instant). O DestinationRule e EnvoyFilter os recursos acima são não fazem parte deste chart – aplique-os com kubectl apply após instalar o release do Helm.

A configuração exata do EnvoyFilter pode variar dependendo da sua versão do Istio. Teste com istioctl proxy-config routes e istioctl proxy-config listeners para verificar se os filtros foram aplicados corretamente.

Outros controladores da Gateway API

Qualquer controlador que implemente a Gateway API do Kubernetes funcionará. Defina api.gateway.className para o seu GatewayClass e adicione configurações específicas do controlador via api.gateway.annotations.

OpenShift Route

Este chart não cria recursos do OpenShift Route. Se precisar usar Routes, defina api.ingress.enabled: false e api.gateway.enabled: false, então crie manualmente um Route para a http-api porta do serviço (<release-name>-api).

Certificados TLS

Tanto as opções Ingress quanto Gateway suportam o provisionamento automático de certificados TLS via cert-manager. Defina clusterIssuer ou issuer em api.ingress.tls ou api.gateway.tls para referenciar seu issuer do cert-manager.

Configuração de proxy

Se o pod da Instant API exigir acesso à internet por meio de um proxy HTTP, defina api.proxy.enabled: true.

As duas opções abaixo são igualmente seguras – escolha a que melhor se adequar à sua configuração.

Opção 1: credenciais embutidas

Caracteres especiais na senha são codificados em percentuais automaticamente pelo chart.

api:
  proxy:
    enabled: true
    url: "http://proxy.local:3128"
    auth:
      login: "your_login"
      password: "your_p@ss:w0rd!"

Opção 2: Secret existente

Use isto quando as credenciais contiverem caracteres difíceis de escapar em YAML, ou quando você quiser manter as credenciais totalmente fora dos arquivos de values. Crie um Secret com a URL completa do proxy pré-codificada:

kubectl -n api-instant create secret generic oz-proxy-creds \
  --from-literal=all_proxy='http://your_login:[e-mail]:3128'

Em seguida, referencie-o em values:

api:
  proxy:
    enabled: true
    url: "http://proxy.local:3128"
    auth:
      existingSecret: oz-proxy-creds

Quando auth.existingSecret está definido, auth.login e auth.password são ignorados. O Secret deve conter uma chave chamada all_proxy com a URL completa do proxy, incluindo credenciais.

Armazenamento em S3

Instant API pode armazenar dados de verificação de liveness em um bucket S3 ou compatível com S3 em vez de armazenamento local. Duas variáveis de ambiente são sempre necessárias para habilitar o S3:

• OZ_INSTANT_SAVING_ARTIFACTS_ENABLED: "true" (para versões de API abaixo de 6.5: OZ_INSTANT_SAVING_ARTIFACTS_IN_S3_ENABLED)

• OZ_FILE_STORAGE_TYPE: "S3".

Parâmetros não sensíveis do S3 vão em api.extraEnvs; as credenciais devem ser colocadas em um Secret pré-criado referenciado por api.extraEnvVarsSecret – suas chaves são injetadas como variáveis de ambiente junto com o ConfigMap.

Opção 1: AWS S3 com chaves de acesso

Crie um Secret com as credenciais:

kubectl -n api-instant create secret generic oz-api-s3-creds \
  --from-literal=OZ_STATIC_S3_ACCESS_KEY='<YOUR_S3_ACCESS_KEY>' \
  --from-literal=OZ_STATIC_S3_SECRET_KEY='<YOUR_S3_SECRET_KEY>'

Referencie-o em values junto com os parâmetros não sensíveis do S3:

api:
  extraEnvVarsSecret: oz-api-s3-creds
  extraEnvs:
    OZ_INSTANT_SAVING_ARTIFACTS_IN_S3_ENABLED: "true"
    OZ_FILE_STORAGE_TYPE: "S3"
    OZ_STATIC_S3_BUCKET: "oz-bucket"
    OZ_STATIC_S3_ENDPOINT_URL: "https://s3.us-east-1.amazonaws.com/"
    OZ_STATIC_S3_REGION_NAME: "us-east-1"
    OZ_STATIC_S3_BUCKET_URL: "None"
    OZ_STATIC_S3_BASE_URL: "http://localhost/static"
    OZ_STATIC_S3_SUFFIX: ""           # pasta raiz no bucket; vazio = raiz do bucket

Opção 2: AWS S3 com função IAM (EKS IRSA)

Use isto ao executar no EKS com IAM Roles for Service Accounts. Não são necessárias chaves de acesso – o pod assume uma função IAM via a service account.

1. Crie o bucket S3.

2. Crie um OIDC Identity Provider no IAM:

• Type: OpenID Connect

• Audience: sts.amazonaws.com

3. Crie uma policy do IAM:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ListBucket",
      "Effect": "Allow",
      "Action": "s3:ListBucket",
      "Resource": "arn:aws:s3:::YOUR_BUCKET_NAME"
    },
    {
      "Sid": "ObjectOperations",
      "Effect": "Allow",
      "Action": [
        "s3:GetObject",
        "s3:PutObject",
        "s3:DeleteObject"
      ],
      "Resource": "arn:aws:s3:::YOUR_BUCKET_NAME/*"
    }
  ]
}

4. Crie uma função IAM com a seguinte política de confiança e, em seguida, anexe a policy da etapa 3:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "<Identity provider ARN>"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "<Identity provider name>:aud": "sts.amazonaws.com"
        }
      }
    }
  ]
}

Exemplo:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::123456789000:oidc-provider/oidc.eks.us-east-2.amazonaws.com/id/1234567890ABCDEFGHIGHKLMOPQRSTUV"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc.eks.us-somewhere-1.amazonaws.com/id/1234567890ABCDEFGHIGHKLMOPQRSTUV:aud": "sts.amazonaws.com"
        }
      }
    }
  ]
}

5. Anote a service account do chart com o ARN da função:

serviceAccount:
  enabled: true
  annotations:
    eks.amazonaws.com/role-arn: "arn:aws:iam::123456789000:role/<YOUR_ROLE_NAME>"
    eks.amazonaws.com/sts-regional-endpoints: "true"

6. Defina variáveis de ambiente do S3 (sem chaves de acesso necessárias):

api:
  extraEnvs:
    OZ_INSTANT_SAVING_ARTIFACTS_IN_S3_ENABLED: "true"
    OZ_FILE_STORAGE_TYPE: "S3"
    OZ_STATIC_S3_BUCKET: "oz-bucket"
    OZ_STATIC_S3_ENDPOINT_URL: "https://s3.us-east-1.amazonaws.com/"
    OZ_STATIC_S3_REGION_NAME: "us-east-1"
    OZ_STATIC_S3_BUCKET_URL: "None"
    OZ_STATIC_S3_BASE_URL: "http://localhost/static"
    OZ_STATIC_S3_SUFFIX: ""

Opção 3: armazenamento compatível com S3 (MinIO, NetApp StorageGRID, etc.)

Compatibilidade testada: MinIO 5.4.0, NetApp StorageGRID 11.8.

kubectl -n api-instant create secret generic oz-api-s3-creds \
  --from-literal=OZ_STATIC_S3_ACCESS_KEY='<YOUR_S3_ACCESS_KEY>' \
  --from-literal=OZ_STATIC_S3_SECRET_KEY='<YOUR_S3_SECRET_KEY>'

api:
  extraEnvVarsSecret: oz-api-s3-creds
  extraEnvs:
    OZ_INSTANT_SAVING_ARTIFACTS_IN_S3_ENABLED: "true"
    OZ_FILE_STORAGE_TYPE: "S3"
    OZ_STATIC_S3_BUCKET: "oz-bucket"
    OZ_STATIC_S3_ENDPOINT_URL: "http://your-s3-host:9000"   # protocolo + host + porta
    OZ_STATIC_S3_REGION_NAME: "us-east-1"                   # qualquer valor aceito pelo seu armazenamento
    OZ_STATIC_S3_BUCKET_URL: "None"
    OZ_STATIC_S3_BASE_URL: "http://localhost/static"
    OZ_STATIC_S3_SUFFIX: ""

Desinstalar

helm uninstall oz-api-instant -n api-instant

Isso não exclui os secrets de JWT e de pull da imagem. Remova-os manualmente, se necessário.