Coletar registros do CRM do Zendesk

Compatível com:

Este documento explica como ingerir registros do gerenciamento de relacionamento com o cliente (CRM) do Zendesk no Google Security Operations usando o Amazon S3.

Antes de começar

Verifique se você tem os pré-requisitos a seguir:

  • Uma instância do Google SecOps.
  • Acesso privilegiado ao Zendesk.
  • Acesso privilegiado à AWS (S3, Identity and Access Management (IAM), Lambda, EventBridge).

Conferir os pré-requisitos do Zendesk

  1. Confirmar plano e função
    1. Você precisa ser um administrador do Zendesk para criar tokens de API / clientes OAuth. A API Audit Logs está disponível apenas no plano Enterprise. Se a sua conta não for do Enterprise, pule audit_logs em RESOURCES.
  2. Ativar o acesso ao token da API (uma vez)
    1. No Admin Center, acesse Apps e integrações > APIs > Configuração da API.
    2. Ative a opção Permitir acesso ao token da API.
  3. Gerar um token de API (para autenticação básica)
    1. Acesse Apps e integrações > APIs > Tokens de API.
    2. Clique em Adicionar token de API > (opcionalmente) adicione uma descrição > Salvar.
    3. Copie e salve o token da API agora, porque não será possível vê-lo novamente.
    4. Salve o e-mail do administrador que será autenticado com esse token.
      • Formato de autenticação básica usado pela Lambda: email_address/token:api_token
  4. (Opcional) Criar um cliente OAuth (para autenticação de portador em vez de token de API)
    1. Acesse Apps e integrações > APIs > Clientes OAuth > Adicionar cliente OAuth.
    2. Preencha os campos Nome, Identificador exclusivo (automático), URLs de redirecionamento (podem ser um marcador de posição se você só gerar tokens com a API) e Salvar.
    3. Crie um token de acesso para a integração e conceda os escopos mínimos exigidos por este guia:
      • tickets:read (para ingressos incrementais)
      • auditlogs:read (para registros de auditoria; somente Enterprise)
      • Se não tiver certeza, read também funciona para acesso somente leitura.
    4. Copie o token de acesso (cole em ZENDESK_BEARER_TOKEN) e registre o ID/chave secreta do cliente de forma segura (para fluxos futuros de atualização de token).

  5. Registre seu URL base do Zendesk

    • Use https://<your_subdomain>.zendesk.com (cole na variável de ambiente ZENDESK_BASE_URL).

    O que copiar e salvar para depois

    • URL de base (por exemplo, https://acme.zendesk.com)
    • Endereço de e-mail do usuário administrador (para autenticação de token da API)
    • Token da API (se estiver usando AUTH_MODE=token)
    • ou token de acesso OAuth (se estiver usando AUTH_MODE=bearer)
    • (Opcional): ID/chave secreta do cliente OAuth para gerenciamento do ciclo de vida

Configurar o bucket do AWS S3 e o IAM para o Google SecOps

  1. Crie um bucket do Amazon S3 seguindo este guia do usuário: Como criar um bucket
  2. Salve o Nome e a Região do bucket para referência futura (por exemplo, zendesk-crm-logs).
  3. Crie um usuário seguindo este guia: Como criar um usuário do IAM.
  4. Selecione o usuário criado.
  5. Selecione a guia Credenciais de segurança.
  6. Clique em Criar chave de acesso na seção Chaves de acesso.
  7. Selecione Serviço de terceiros como Caso de uso.
  8. Clique em Próxima.
  9. Opcional: adicione uma tag de descrição.
  10. Clique em Criar chave de acesso.
  11. Clique em Fazer o download do arquivo .CSV para salvar a chave de acesso e a chave de acesso secreta para referência futura.
  12. Clique em Concluído.
  13. Selecione a guia Permissões.
  14. Clique em Adicionar permissões na seção Políticas de permissões.
  15. Selecione Adicionar permissões.
  16. Selecione Anexar políticas diretamente.
  17. Pesquise a política AmazonS3FullAccess.
  18. Selecione a política.
  19. Clique em Próxima.
  20. Clique em Adicionar permissões

Configurar a política e o papel do IAM para uploads do S3

  1. No console da AWS, acesse IAM > Políticas.
  2. Clique em Criar política > guia JSON.
  3. Copie e cole a política a seguir.

  4. JSON da política (substitua zendesk-crm-logs se você tiver inserido um nome de bucket diferente):

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

  5. Clique em Próxima > Criar política.

  6. Acesse IAM > Funções > Criar função > Serviço da AWS > Lambda.

  7. Anexe a política recém-criada.

  8. Nomeie a função como ZendeskCRMToS3Role e clique em Criar função.

Criar a função Lambda

  1. No console da AWS, acesse Lambda > Functions > Create function.
  2. Clique em Criar do zero.

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

    Configuração Valor
    Nome zendesk_crm_to_s3
    Ambiente de execução Python 3.13
    Arquitetura x86_64
    Função de execução ZendeskCRMToS3Role

  4. Depois que a função for criada, abra a guia Código, exclua o stub e cole o código a seguir (zendesk_crm_to_s3.py).

    #!/usr/bin/env python3

import os, json, time, base64
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
import boto3

S3_BUCKET    = os.environ["S3_BUCKET"]
S3_PREFIX    = os.environ.get("S3_PREFIX", "zendesk/crm/")
STATE_KEY    = os.environ.get("STATE_KEY", "zendesk/crm/state.json")
BASE_URL     = os.environ["ZENDESK_BASE_URL"].rstrip("/")  # e.g. https://your_subdomain.zendesk.com
AUTH_MODE    = os.environ.get("AUTH_MODE", "token").lower()  # token|bearer
EMAIL        = os.environ.get("ZENDESK_EMAIL", "")
API_TOKEN    = os.environ.get("ZENDESK_API_TOKEN", "")
BEARER       = os.environ.get("ZENDESK_BEARER_TOKEN", "")
RESOURCES    = [r.strip() for r in os.environ.get("RESOURCES", "audit_logs,incremental_tickets").split(",") if r.strip()]
MAX_PAGES    = int(os.environ.get("MAX_PAGES", "20"))
LOOKBACK     = int(os.environ.get("LOOKBACK_SECONDS", "3600"))  # 1h default
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))

s3 = boto3.client("s3")

def _headers() -> dict:
    if AUTH_MODE == "bearer" and BEARER:
        return {"Authorization": f"Bearer {BEARER}", "Accept": "application/json"}
    if AUTH_MODE == "token" and EMAIL and API_TOKEN:
        token = base64.b64encode(f"{EMAIL}/token:{API_TOKEN}".encode()).decode()
        return {"Authorization": f"Basic {token}", "Accept": "application/json"}
    raise RuntimeError("Invalid auth settings: provide token (EMAIL + API_TOKEN) or BEARER")

def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        b = obj["Body"].read()
        return json.loads(b) if b else {"audit_logs": {}, "incremental_tickets": {}}
    except Exception:
        return {"audit_logs": {}, "incremental_tickets": {}}

def _put_state(st: dict) -> None:
    s3.put_object(
        Bucket=S3_BUCKET, Key=STATE_KEY,
        Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
        ContentType="application/json",
    )

def _http_get_json(url: str) -> dict:
    attempt = 0
    while True:
        try:
            req = Request(url, method="GET")
            for k, v in _headers().items():
                req.add_header(k, v)
            with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                ra = 1 + attempt
                try:
                    ra = int(e.headers.get("Retry-After", ra))
                except Exception:
                    pass
                time.sleep(max(1, ra))
                attempt += 1
                continue
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(1 + attempt)
                attempt += 1
                continue
            raise

def _put_page(payload: dict, resource: str) -> str:
    ts = time.gmtime()
    key = f"{S3_PREFIX}/{time.strftime('%Y/%m/%d/%H%M%S', ts)}-zendesk-{resource}.json"
    s3.put_object(
        Bucket=S3_BUCKET, Key=key,
        Body=json.dumps(payload, separators=(",", ":")).encode("utf-8"),
        ContentType="application/json",
    )
    return key

def fetch_audit_logs(state: dict):
    """GET /api/v2/audit_logs.json with pagination via `next_page` (Zendesk)."""
    next_url = state.get("next_url") or f"{BASE_URL}/api/v2/audit_logs.json?page=1"
    pages = 0
    written = 0
    last_next = None
    while pages < MAX_PAGES and next_url:
        data = _http_get_json(next_url)
        _put_page(data, "audit_logs")
        written += len(data.get("audit_logs", []))
        last_next = data.get("next_page")
        next_url = last_next
        pages += 1
    return {"resource": "audit_logs", "pages": pages, "written": written, "next_url": last_next}

def fetch_incremental_tickets(state: dict):
    """Cursor-based incremental export: /api/v2/incremental/tickets/cursor.json (pagination via `links.next`)."""
    next_link = state.get("next")
    if not next_link:
        start = int(time.time()) - LOOKBACK
        next_link = f"{BASE_URL}/api/v2/incremental/tickets/cursor.json?start_time={start}"
    pages = 0
    written = 0
    last_next = None
    while pages < MAX_PAGES and next_link:
        data = _http_get_json(next_link)
        _put_page(data, "incremental_tickets")
        written += len(data.get("tickets", []))
        links = data.get("links") or {}
        next_link = links.get("next")
        last_next = next_link
        pages += 1
    return {"resource": "incremental_tickets", "pages": pages, "written": written, "next": last_next}

def lambda_handler(event=None, context=None):
    state = _get_state()
    summary = []

    if "audit_logs" in RESOURCES:
        res = fetch_audit_logs(state.get("audit_logs", {}))
        state["audit_logs"] = {"next_url": res.get("next_url")}
        summary.append(res)

    if "incremental_tickets" in RESOURCES:
        res = fetch_incremental_tickets(state.get("incremental_tickets", {}))
        state["incremental_tickets"] = {"next": res.get("next")}
        summary.append(res)

    _put_state(state)
    return {"ok": True, "summary": summary}

if __name__ == "__main__":
    print(lambda_handler())

  5. Acesse Configuração > Variáveis de ambiente.

  6. Clique em Editar > Adicionar nova variável de ambiente.

  7. Insira as variáveis de ambiente fornecidas na tabela a seguir, substituindo os valores de exemplo pelos seus.

    Variáveis de ambiente

    Chave Valor de exemplo
    S3_BUCKET zendesk-crm-logs
    S3_PREFIX zendesk/crm/
    STATE_KEY zendesk/crm/state.json
    ZENDESK_BASE_URL https://your_subdomain.zendesk.com
    AUTH_MODE token
    ZENDESK_EMAIL analyst@example.com
    ZENDESK_API_TOKEN <api_token>
    ZENDESK_BEARER_TOKEN <leave empty unless using OAuth bearer>
    RESOURCES audit_logs,incremental_tickets
    MAX_PAGES 20
    LOOKBACK_SECONDS 3600
    HTTP_TIMEOUT 60

  8. Depois que a função for criada, permaneça na página dela ou abra Lambda > Functions > sua-função.

  9. Selecione a guia Configuração.

  10. No painel Configuração geral, clique em Editar.

  11. Mude Tempo limite para 5 minutos (300 segundos) e clique em Salvar.

Criar uma programação do EventBridge

  1. Acesse Amazon EventBridge > Scheduler > Criar programação.
  2. Informe os seguintes detalhes de configuração:
    • Programação recorrente: Taxa (1 hour).
    • Destino: sua função Lambda zendesk_crm_to_s3.
    • Nome: zendesk_crm_to_s3-1h.
  3. Clique em Criar programação.

(Opcional) Criar um usuário e chaves do IAM somente leitura para o Google SecOps

  1. Acesse Console da AWS > IAM > Usuários > Adicionar usuários.
  2. Clique em Add users.
  3. Informe os seguintes detalhes de configuração:
    • Usuário: insira secops-reader.
    • Tipo de acesso: selecione Chave de acesso – Acesso programático.
  4. Clique em Criar usuário.
  5. Anexe a política de leitura mínima (personalizada): Usuários > secops-reader > Permissões > Adicionar permissões > Anexar políticas diretamente > Criar política.

  6. JSON:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::zendesk-crm-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::zendesk-crm-logs"
    }
  ]
}

  7. Name = secops-reader-policy.

  8. Clique em Criar política > pesquisar/selecionar > Próxima > Adicionar permissões.

  9. Crie uma chave de acesso para secops-reader: Credenciais de segurança > Chaves de acesso.

  10. Clique em Criar chave de acesso.

  11. Faça o download do .CSV. Cole esses valores no feed.

Configurar um feed no Google SecOps para ingerir registros do CRM do Zendesk

  1. Acesse Configurações do SIEM > Feeds.
  2. Clique em + Adicionar novo feed.
  3. No campo Nome do feed, insira um nome para o feed (por exemplo, Zendesk CRM logs).
  4. Selecione Amazon S3 V2 como o Tipo de origem.
  5. Selecione Zendesk CRM como o Tipo de registro.
  6. Clique em Próxima.
  7. Especifique valores para os seguintes parâmetros de entrada:
    • URI do S3: s3://zendesk-crm-logs/zendesk/crm/
    • Opções de exclusão de fontes: selecione a opção de exclusão de acordo com sua preferência.
    • Idade máxima do arquivo: inclui arquivos modificados no último número de dias. O padrão é de 180 dias.
    • ID da chave de acesso: chave de acesso do usuário com acesso ao bucket do S3.
    • Chave de acesso secreta: chave secreta do usuário com acesso ao bucket do S3.
    • Namespace do recurso: o namespace do recurso.
    • Rótulos de ingestão: o rótulo aplicado aos eventos deste feed.
  8. Clique em Próxima.
  9. Revise a nova configuração do feed na tela Finalizar e clique em Enviar.

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