Recolha registos de auditoria da Harness IO

Suportado em:

Google secops SIEM

Nota: esta funcionalidade está abrangida pelos Termos das Ofertas de Pré-DG dos Termos Específicos do Serviço de Operações de Segurança da Google. As funcionalidades de pré-DG podem ter suporte limitado e as alterações às funcionalidades de pré-DG podem não ser compatíveis com outras versões de pré-DG. Para mais informações, consulte as diretrizes dos serviços de apoio técnico do Google SecOps e os Termos Específicos dos Serviços do Google SecOps.

Este documento explica como carregar registos de auditoria do Harness IO para o Google Security Operations através do Amazon S3.

Antes de começar

Certifique-se de que cumpre os seguintes pré-requisitos:

• Uma instância do Google SecOps
• Acesso privilegiado ao Harness com autorizações para:
  • Crie chaves da API
  • Aceda aos registos de auditoria
  • Veja as definições da conta
• Acesso privilegiado à AWS (S3, IAM, Lambda e EventBridge).

Recolha credenciais da API Harness

Crie uma chave da API no Harness

1. Inicie sessão na Harness Platform.
2. Clique no seu perfil de utilizador.
3. Aceda a As minhas chaves da API.
4. Clique em + Chave da API.
5. Forneça os seguintes detalhes de configuração:
   • Nome: introduza um nome descritivo (por exemplo, Google SecOps Integration).
   • Descrição: descrição opcional.
6. Clique em Guardar.
7. Clique em + Token para criar um novo token.
8. Forneça os seguintes detalhes de configuração:
   • Nome: introduza Chronicle Feed Token.
   • Definir validade: selecione um prazo de validade adequado ou Sem validade (para utilização em produção).
9. Clique em Gerar token.

10. Copie e guarde o valor do token de forma segura. Este token vai ser usado como o valor do cabeçalho x-api-key.

    Nota: o token é apresentado apenas uma vez. Se o perder, tem de gerar um novo token.

Obtenha o ID da conta do Harness

1. Na plataforma Harness, tome nota do ID da conta a partir do URL.
   • Exemplo de URL: https://app.harness.io/ng/account/YOUR_ACCOUNT_ID/...
   • A parte YOUR_ACCOUNT_ID é o identificador da sua conta.
2. Em alternativa, aceda a Account Settings > Overview para ver o seu identificador da conta.

3. Copie e guarde o ID da conta para utilização na função Lambda.

   Nota: o ID da conta é necessário para todos os pedidos de API ao Harness.

Configure o contentor do AWS S3 e o IAM para o Google SecOps

1. Crie um contentor do Amazon S3 seguindo este manual do utilizador: Criar um contentor
2. Guarde o Nome e a Região do contentor para referência futura (por exemplo, harness-io-logs).
3. Crie um utilizador seguindo este guia do utilizador: criar um utilizador do IAM.
4. Selecione o utilizador criado.
5. Selecione o separador Credenciais de segurança.
6. Clique em Criar chave de acesso na secção Chaves de acesso.
7. Selecione Serviço de terceiros como Exemplo de utilização.
8. Clicar em Seguinte.
9. Opcional: adicione uma etiqueta de descrição.
10. Clique em Criar chave de acesso.
11. Clique em Transferir ficheiro CSV para guardar a chave de acesso e a chave de acesso secreta para referência futura.
12. Clique em Concluído.
13. Selecione o separador Autorizações.
14. Clique em Adicionar autorizações na secção Políticas de autorizações.
15. Selecione Adicionar autorizações.
16. Selecione Anexar políticas diretamente.
17. Pesquise a política AmazonS3FullAccess.
18. Selecione a política.
19. Clicar em Seguinte.
20. Clique em Adicionar autorizações.

Configure a política e a função de IAM para carregamentos do Lambda S3

1. Na consola da AWS, aceda a IAM > Políticas > Criar política > separador JSON.

2. Copie e cole a seguinte política:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutHarnessObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::harness-io-logs/harness/audit/*"
       },
       {
         "Sid": "AllowGetStateObject",
         "Effect": "Allow",
         "Action": "s3:GetObject",
         "Resource": "arn:aws:s3:::harness-io-logs/harness/audit/state.json"
       }
     ]
   }
   

   • Substitua harness-io-logs se tiver introduzido um nome de contentor diferente.

3. Clicar em Seguinte.

4. Dê um nome à política HarnessToS3Policy e clique em Criar política.

5. Aceda a IAM > Funções > Criar função.

6. Selecione Serviço AWS como tipo de entidade fidedigna.

7. Selecione Lambda como exemplo de utilização.

8. Clicar em Seguinte.

9. Pesquise e selecione as seguintes políticas:

   • HarnessToS3Policy (a política que acabou de criar)
   • AWSLambdaBasicExecutionRole (para registos do CloudWatch)

10. Clicar em Seguinte.

11. Dê o nome HarnessAuditLambdaRole à função e clique em Criar função.

Crie a função Lambda

1. Na consola da AWS, aceda a Lambda > Functions > Create function.
2. Clique em Criar do zero.

3. Faculte os seguintes detalhes de configuração:

   Definição	Valor
   Nome	harness-audit-to-s3
   Runtime	Python 3.13
   Arquitetura	x86_64
   Função de execução	HarnessAuditLambdaRole

4. Clique em Criar função.

5. Depois de criar a função, abra o separador Código.

6. Elimine o código de substituição predefinido e introduza o seguinte código da função Lambda:

   • Código da função Lambda (harness_audit_to_s3.py)

     #!/usr/bin/env python3
     """
     Harness.io Audit Logs to S3 Lambda
     Fetches audit logs from Harness API and writes to S3 for Chronicle ingestion.
     """
     import os
     import json
     import time
     import uuid
     import logging
     import urllib.parse
     from datetime import datetime, timedelta, timezone
     from urllib.request import Request, urlopen
     from urllib.error import HTTPError, URLError
     import boto3
     
     # Configuration from Environment Variables
     API_BASE = os.environ.get("HARNESS_API_BASE", "https://app.harness.io").rstrip("/")
     ACCOUNT_ID = os.environ["HARNESS_ACCOUNT_ID"]
     API_KEY = os.environ["HARNESS_API_KEY"]
     BUCKET = os.environ["S3_BUCKET"]
     PREFIX = os.environ.get("S3_PREFIX", "harness/audit").strip("/")
     STATE_KEY = os.environ.get("STATE_KEY", "harness/audit/state.json")
     PAGE_SIZE = min(int(os.environ.get("PAGE_SIZE", "50")), 100)
     START_MINUTES_BACK = int(os.environ.get("START_MINUTES_BACK", "60"))
     
     # Optional filters (NEW)
     FILTER_MODULES = os.environ.get("FILTER_MODULES", "").split(",") if os.environ.get("FILTER_MODULES") else None
     FILTER_ACTIONS = os.environ.get("FILTER_ACTIONS", "").split(",") if os.environ.get("FILTER_ACTIONS") else None
     STATIC_FILTER = os.environ.get("STATIC_FILTER")  # e.g., "EXCLUDE_LOGIN_EVENTS"
     MAX_RETRIES = int(os.environ.get("MAX_RETRIES", "3"))
     
     # AWS clients
     s3 = boto3.client("s3")
     
     # HTTP headers for Harness API
     HDRS = {
         "x-api-key": API_KEY,
         "Content-Type": "application/json",
         "Accept": "application/json",
     }
     
     # Logging configuration
     logger = logging.getLogger()
     logger.setLevel(logging.INFO)
     
     # ============================================
     # State Management Functions
     # ============================================
     def _read_state():
         """Read checkpoint state from S3."""
         try:
             obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
             state = json.loads(obj["Body"].read())
     
             since_ms = state.get("since")
             page_token = state.get("pageToken")
     
             logger.info(f"State loaded: since={since_ms}, pageToken={page_token}")
             return since_ms, page_token
     
         except s3.exceptions.NoSuchKey:
             logger.info("No state file found, starting fresh collection")
             start_time = datetime.now(timezone.utc) - timedelta(minutes=START_MINUTES_BACK)
             since_ms = int(start_time.timestamp() * 1000)
             logger.info(f"Initial since timestamp: {since_ms} ({start_time.isoformat()})")
             return since_ms, None
     
         except Exception as e:
             logger.error(f"Error reading state: {e}")
             raise
     
     def _write_state(since_ms: int, page_token: str = None):
         """Write checkpoint state to S3."""
         state = {
             "since": since_ms,
             "pageToken": page_token,
             "lastRun": int(time.time() * 1000),
             "lastRunISO": datetime.now(timezone.utc).isoformat()
         }
     
         try:
             s3.put_object(
                 Bucket=BUCKET,
                 Key=STATE_KEY,
                 Body=json.dumps(state, indent=2).encode(),
                 ContentType="application/json"
             )
             logger.info(f"State saved: since={since_ms}, pageToken={page_token}")
         except Exception as e:
             logger.error(f"Error writing state: {e}")
             raise
     
     # ============================================
     # Harness API Functions
     # ============================================
     def _fetch_harness_audits(since_ms: int, page_token: str = None, retry_count: int = 0):
         """
         Fetch audit logs from Harness API with retry logic.
     
         API Endpoint: POST /audit/api/audits/listV2
         Documentation: https://apidocs.harness.io/audit/getauditeventlistv2
         """
         try:
             # Build URL with query parameters
             url = (
                 f"{API_BASE}/audit/api/audits/listV2"
                 f"?accountIdentifier={urllib.parse.quote(ACCOUNT_ID)}"
                 f"&pageSize={PAGE_SIZE}"
             )
     
             if page_token:
                 url += f"&pageToken={urllib.parse.quote(page_token)}"
     
             logger.info(f"Fetching from: {url[:100]}...")
     
             # Build request body with time filter and optional filters
             body_data = {
                 "startTime": since_ms,
                 "endTime": int(time.time() * 1000),
                 "filterType": "Audit" 
             }
     
             if FILTER_MODULES:
                 body_data["modules"] = [m.strip() for m in FILTER_MODULES if m.strip()]
                 logger.info(f"Applying module filter: {body_data['modules']}")
     
             if FILTER_ACTIONS:
                 body_data["actions"] = [a.strip() for a in FILTER_ACTIONS if a.strip()]
                 logger.info(f"Applying action filter: {body_data['actions']}")
     
             if STATIC_FILTER:
                 body_data["staticFilter"] = STATIC_FILTER
                 logger.info(f"Applying static filter: {STATIC_FILTER}")
     
             logger.debug(f"Request body: {json.dumps(body_data)}")
     
             # Make POST request
             req = Request(
                 url,
                 data=json.dumps(body_data).encode('utf-8'),
                 headers=HDRS,
                 method="POST"
             )
     
             resp = urlopen(req, timeout=30)
             resp_text = resp.read().decode('utf-8')
             resp_data = json.loads(resp_text)
     
             if "status" not in resp_data:
                 logger.warning(f"Response missing 'status' field: {resp_text[:200]}")
     
             # Check response status
             if resp_data.get("status") != "SUCCESS":
                 error_msg = resp_data.get("message", "Unknown error")
                 raise Exception(f"API returned status: {resp_data.get('status')} - {error_msg}")
     
             # Extract data from response structure
             data_obj = resp_data.get("data", {})
     
             if not data_obj:
                 logger.warning("Response 'data' object is empty or missing")
     
             events = data_obj.get("content", [])
             has_next = data_obj.get("hasNext", False)
             next_token = data_obj.get("pageToken")
     
             logger.info(f"API response: {len(events)} events, hasNext={has_next}, pageToken={next_token}")
     
             if not events and data_obj:
                 logger.info(f"Empty events but data present. Data keys: {list(data_obj.keys())}")
     
             return {
                 "events": events,
                 "hasNext": has_next,
                 "pageToken": next_token
             }
     
         except HTTPError as e:
             error_body = e.read().decode() if hasattr(e, 'read') else ''
     
             if e.code == 401:
                 logger.error("Authentication failed: Invalid API key")
                 raise Exception("Invalid Harness API key. Check HARNESS_API_KEY environment variable.")
     
             elif e.code == 403:
                 logger.error("Authorization failed: Insufficient permissions")
                 raise Exception("API key lacks required audit:read permissions")
     
             elif e.code == 429:
                 retry_after = int(e.headers.get("Retry-After", "60"))
                 logger.warning(f"Rate limit exceeded. Retry after {retry_after} seconds (attempt {retry_count + 1}/{MAX_RETRIES})")
     
                 if retry_count < MAX_RETRIES:
                     logger.info(f"Waiting {retry_after} seconds before retry...")
                     time.sleep(retry_after)
                     logger.info(f"Retrying request (attempt {retry_count + 2}/{MAX_RETRIES})")
                     return _fetch_harness_audits(since_ms, page_token, retry_count + 1)
                 else:
                     raise Exception(f"Max retries ({MAX_RETRIES}) exceeded for rate limiting")
     
             elif e.code == 400:
                 logger.error(f"Bad request: {error_body}")
                 raise Exception(f"Invalid request parameters: {error_body}")
     
             else:
                 logger.error(f"HTTP {e.code}: {e.reason} - {error_body}")
                 raise Exception(f"Harness API error {e.code}: {e.reason}")
     
         except URLError as e:
             logger.error(f"Network error: {e.reason}")
             raise Exception(f"Failed to connect to Harness API: {e.reason}")
     
         except json.JSONDecodeError as e:
             logger.error(f"Invalid JSON response: {e}")
             logger.error(f"Response text (first 500 chars): {resp_text[:500] if 'resp_text' in locals() else 'N/A'}")
             raise Exception("Harness API returned invalid JSON")
     
         except Exception as e:
             logger.error(f"Unexpected error in _fetch_harness_audits: {e}", exc_info=True)
             raise
     
     # ============================================
     # S3 Upload Functions
     # ============================================
     def _upload_to_s3(events: list) -> str:
         """
         Upload audit events to S3 in JSONL format.
         Each line is a complete JSON object (one event per line).
         """
         if not events:
             logger.info("No events to upload")
             return None
     
         try:
             # Create JSONL content (one JSON object per line)
             jsonl_lines = [json.dumps(event) for event in events]
             jsonl_content = "\n".join(jsonl_lines)
     
             # Generate S3 key with timestamp and UUID
             timestamp = datetime.now(timezone.utc)
             key = (
                 f"{PREFIX}/"
                 f"{timestamp:%Y/%m/%d}/"
                 f"harness-audit-{timestamp:%Y%m%d-%H%M%S}-{uuid.uuid4()}.jsonl"
             )
     
             # Upload to S3
             s3.put_object(
                 Bucket=BUCKET,
                 Key=key,
                 Body=jsonl_content.encode('utf-8'),
                 ContentType="application/x-ndjson",
                 Metadata={
                     "event-count": str(len(events)),
                     "source": "harness-audit-lambda",
                     "collection-time": timestamp.isoformat()
                 }
             )
     
             logger.info(f"Uploaded {len(events)} events to s3://{BUCKET}/{key}")
             return key
     
         except Exception as e:
             logger.error(f"Error uploading to S3: {e}", exc_info=True)
             raise
     
     # ============================================
     # Main Orchestration Function
     # ============================================
     def fetch_and_store():
         """
         Main function to fetch audit logs from Harness and store in S3.
         Handles pagination and state management.
         """
         logger.info("=== Harness Audit Collection Started ===")
         logger.info(f"Configuration: API_BASE={API_BASE}, ACCOUNT_ID={ACCOUNT_ID[:8]}..., PAGE_SIZE={PAGE_SIZE}")
     
         if FILTER_MODULES:
             logger.info(f"Module filter enabled: {FILTER_MODULES}")
         if FILTER_ACTIONS:
             logger.info(f"Action filter enabled: {FILTER_ACTIONS}")
         if STATIC_FILTER:
             logger.info(f"Static filter enabled: {STATIC_FILTER}")
     
         try:
             # Step 1: Read checkpoint state
             since_ms, page_token = _read_state()
     
             if page_token:
                 logger.info(f"Resuming pagination from saved pageToken")
             else:
                 since_dt = datetime.fromtimestamp(since_ms / 1000, tz=timezone.utc)
                 logger.info(f"Starting new collection from: {since_dt.isoformat()}")
     
             # Step 2: Collect all events with pagination
             all_events = []
             current_page_token = page_token
             page_count = 0
             max_pages = 100  # Safety limit
             has_next = True
     
             while has_next and page_count < max_pages:
                 page_count += 1
                 logger.info(f"--- Fetching page {page_count} ---")
     
                 # Fetch one page of results
                 result = _fetch_harness_audits(since_ms, current_page_token)
     
                 # Extract events
                 events = result.get("events", [])
                 all_events.extend(events)
     
                 logger.info(f"Page {page_count}: {len(events)} events (total: {len(all_events)})")
     
                 # Check pagination status
                 has_next = result.get("hasNext", False)
                 current_page_token = result.get("pageToken")
     
                 if not has_next:
                     logger.info("Pagination complete (hasNext=False)")
                     break
     
                 if not current_page_token:
                     logger.warning("hasNext=True but no pageToken, stopping pagination")
                     break
     
                 # Small delay between pages to avoid rate limiting
                 time.sleep(0.5)
     
             if page_count >= max_pages:
                 logger.warning(f"Reached max pages limit ({max_pages}), stopping")
     
             # Step 3: Upload collected events to S3
             if all_events:
                 s3_key = _upload_to_s3(all_events)
                 logger.info(f"Successfully uploaded {len(all_events)} total events")
             else:
                 logger.info("No new events to upload")
                 s3_key = None
     
             # Step 4: Update checkpoint state
             if not has_next:
                 # Pagination complete - update since to current time for next run
                 new_since = int(time.time() * 1000)
                 _write_state(new_since, None)
                 logger.info(f"Pagination complete, state updated with new since={new_since}")
             else:
                 # Pagination incomplete - save pageToken for continuation
                 _write_state(since_ms, current_page_token)
                 logger.info(f"Pagination incomplete, saved pageToken for next run")
     
             # Step 5: Return result
             result = {
                 "statusCode": 200,
                 "message": "Success",
                 "eventsCollected": len(all_events),
                 "pagesProcessed": page_count,
                 "paginationComplete": not has_next,
                 "s3Key": s3_key,
                 "filters": {
                     "modules": FILTER_MODULES,
                     "actions": FILTER_ACTIONS,
                     "staticFilter": STATIC_FILTER
                 }
             }
     
             logger.info(f"Collection completed: {json.dumps(result)}")
             return result
     
         except Exception as e:
             logger.error(f"Collection failed: {e}", exc_info=True)
     
             result = {
                 "statusCode": 500,
                 "message": "Error",
                 "error": str(e),
                 "errorType": type(e).__name__
             }
     
             return result
     
         finally:
             logger.info("=== Harness Audit Collection Finished ===")
     
     # ============================================
     # Lambda Handler
     # ============================================
     def lambda_handler(event, context):
         """AWS Lambda handler function."""
         return fetch_and_store()
     
     # ============================================
     # Local Testing
     # ============================================
     if __name__ == "__main__":
         # For local testing
         result = lambda_handler(None, None)
         print(json.dumps(result, indent=2))
     

     Nota: este script é fornecido como exemplo e não é oficialmente suportado. Agradecemos o feedback sobre como podemos melhorá-lo. Para enviar feedback, clique em Enviar feedback > Feedback do produto de segurança do Google SecOps nesta página.

7. Clique em Implementar para guardar o código da função.

Configure variáveis de ambiente do Lambda

1. Na página da função Lambda, selecione o separador Configuração.
2. Clique em Variáveis de ambiente na barra lateral esquerda.
3. Clique em Edit.

4. Clique em Adicionar variável de ambiente para cada um dos seguintes:

   Variáveis de ambiente obrigatórias:

   Chave	Valor	Descrição
   HARNESS_ACCOUNT_ID	O ID da sua conta do Harness	Identificador da conta da Harness
   HARNESS_API_KEY	O token da chave da API	Token com autorizações audit:read
   S3_BUCKET	harness-io-logs	Nome do contentor do S3
   S3_PREFIX	harness/audit	Prefixo para objetos S3
   STATE_KEY	harness/audit/state.json	Caminho do ficheiro de estado no S3

   Variáveis de ambiente opcionais:

   Chave	Valor predefinido	Descrição
   HARNESS_API_BASE	https://app.harness.io	URL base da API Harness
   PAGE_SIZE	50	Eventos por página (máximo de 100)
   START_MINUTES_BACK	60	Período de análise inicial em minutos
   FILTER_MODULES	Nenhum	Módulos separados por vírgulas (por exemplo, CD,CI,CE)
   FILTER_ACTIONS	Nenhum	Ações separadas por vírgulas (por exemplo, CREATE,UPDATE,DELETE)
   STATIC_FILTER	Nenhum	Filtro predefinido: EXCLUDE_LOGIN_EVENTS ou EXCLUDE_SYSTEM_EVENTS
   MAX_RETRIES	3	Número máximo de tentativas para a limitação de velocidade

5. Clique em Guardar.

Configure o tempo limite e a memória do Lambda

1. Na página da função Lambda, selecione o separador Configuração.
2. Clique em Configuração geral na barra lateral esquerda.
3. Clique em Edit.
4. Forneça os seguintes detalhes de configuração:
   • Memória: 256 MB (recomendado)
   • Limite de tempo: 5 min 0 sec (300 segundos)
5. Clique em Guardar.

Nota: o limite de tempo de 5 minutos é um limite máximo rígido. Se a função ainda estiver em execução quando o temporizador expirar, o AWS Lambda termina-a. Para execuções mais curtas, só lhe é faturado o tempo de execução real.

Crie um horário do EventBridge

1. Aceda a Amazon EventBridge > Scheduler > Create schedule.
2. Forneça os seguintes detalhes de configuração:
   • Nome do horário: introduza harness-audit-hourly.
   • Descrição: descrição opcional.
3. Clicar em Seguinte.
4. Em Padrão de programação, selecione Programação recorrente.
5. Selecione Programação baseada em tarifas.
6. Forneça os seguintes detalhes de configuração:
   • Expressão de taxa: introduza 1 hour.
7. Clicar em Seguinte.
8. Em Destino, indique os seguintes detalhes de configuração:
   • API de destino: selecione AWS Lambda Invoke.
   • Função Lambda: selecione a sua função harness-audit-to-s3.
9. Clicar em Seguinte.
10. Reveja a configuração da programação.
11. Clique em Criar horário.

Nota: a função Lambda vai ser executada automaticamente a cada hora para recolher novos registos de auditoria.

Crie um utilizador da IAM só de leitura para o Google SecOps

Este utilizador do IAM permite que o Google SecOps leia registos do contentor do S3.

1. Aceda a AWS Console > IAM > Users > Create user.
2. Forneça os seguintes detalhes de configuração:
   • Nome de utilizador: introduza chronicle-s3-reader.
3. Clicar em Seguinte.
4. Selecione Anexar políticas diretamente.
5. Clique em Criar política.
6. Selecione o separador JSON.

7. Cole a seguinte política:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": [
           "s3:GetObject"
         ],
         "Resource": "arn:aws:s3:::harness-io-logs/harness/audit/*"
       },
       {
         "Effect": "Allow",
         "Action": [
           "s3:ListBucket"
         ],
         "Resource": "arn:aws:s3:::harness-io-logs",
         "Condition": {
           "StringLike": {
             "s3:prefix": "harness/audit/*"
           }
         }
       }
     ]
   }
   

8. Clicar em Seguinte.

9. Atribua um nome à política ChronicleHarnessS3ReadPolicy.

10. Clique em Criar política.

11. Regresse ao separador de criação de utilizadores e atualize a lista de políticas.

12. Pesquise e selecione ChronicleHarnessS3ReadPolicy.

13. Clicar em Seguinte.

14. Reveja e clique em Criar utilizador.

Crie chaves de acesso para o utilizador leitor

1. Na página Utilizadores do IAM, selecione o utilizador chronicle-s3-reader.
2. Selecione o separador Credenciais de segurança.
3. Clique em Criar chave de acesso.
4. Selecione Serviço de terceiros como exemplo de utilização.
5. Clicar em Seguinte.
6. Opcional: adicione a etiqueta de descrição.
7. Clique em Criar chave de acesso.
8. Clique em Transferir ficheiro CSV para guardar o ID da chave de acesso e a chave de acesso secreta.
9. Clique em Concluído.

Nota: armazene estas credenciais em segurança. Precisa deles para configurar o feed do Google SecOps.

Configure um feed no Google SecOps para carregar registos do Harness IO

1. Aceda a Definições do SIEM > Feeds.
2. Clique em Adicionar novo.
3. Na página seguinte, clique em Configurar um único feed.
4. No campo Nome do feed, introduza um nome para o feed (por exemplo, Harness Audit Logs).
5. Selecione Amazon S3 V2 como o Tipo de origem.
6. Selecione Harness IO como o Tipo de registo.
7. Clicar em Seguinte.

8. Especifique valores para os seguintes parâmetros de entrada:

   • URI do S3: introduza o URI do contentor do S3 com o caminho do prefixo: s3://harness-io-logs/harness/audit/

   • Opção de eliminação da origem: selecione a opção de eliminação de acordo com a sua preferência:

     • Nunca: nunca elimina ficheiros após transferências (recomendado inicialmente).
     • Em caso de êxito: elimina todos os ficheiros e diretórios vazios após a transferência bem-sucedida.
     Nota: se selecionar a opção de eliminação "No êxito", certifique-se de que o utilizador do IAM tem a autorização s3:DeleteObject.

   • Idade máxima do ficheiro: inclua ficheiros modificados no último número de dias. A predefinição é 180 dias.

   • ID da chave de acesso: introduza o ID da chave de acesso do utilizador do chronicle-s3-reader.

   • Chave de acesso secreta: introduza a chave de acesso secreta do utilizador chronicle-s3-reader.

   • Espaço de nomes do recurso: o espaço de nomes do recurso. Introduza harness.audit.

   • Etiquetas de carregamento: etiquetas opcionais a aplicar a eventos deste feed.

9. Clicar em Seguinte.

10. Reveja a nova configuração do feed no ecrã Finalizar e, de seguida, clique em Enviar.

Precisa de mais ajuda? Receba respostas de membros da comunidade e profissionais da Google SecOps.