Inicio / Conectar tu nube

Conectar tu nube

El asistente de conexión te guía por unos pocos pasos —elige tu nube, define el alcance y el método, y conecta—. En todos, Cloura recibe credenciales de solo lectura: jamás pide permisos para modificar tus recursos.

Solo lectura, siempre El asistente crea un rol/identidad de lectura (AWS ClouraReadOnly, Azure Reader, GCP WIF a un service account de lectura). Puedes revocarlo cuando quieras sin afectar tu infraestructura.

Paso 1 — Elige tu nube

Abre Ajustes → Cuentas → Conectar nube y selecciona el proveedor. El mismo asistente conecta AWS, Azure o GCP. El panel Seguro por diseño recuerda que el acceso es de solo lectura.

app.cloura.ai/onboarding
1 Nube 2 Alcance 3 Método 4 Conectar

Conecta tu Proveedor Cloud

Cloura necesita acceso de solo lectura para analizar tu Proveedor Cloud. El mismo flujo conecta cualquier proveedor — elige uno y sigue los pasos.

Paso 1 del asistente real: elegir el proveedor.

Paso 2 — Alcance y método

Elige el alcance (una cuenta individual o toda tu organización) y el método de conexión: una guía paso a paso por la consola de tu nube, o unos comandos de CLI. Ambos crean exactamente el mismo acceso de solo lectura.

app.cloura.ai/onboarding
1 Nube 2 Alcance 3 Método 4 Conectar
AWSAWS · Individual

Elige el método de conexión

Paso de método: "Guía por consola" o "CLI" — ambos otorgan solo lectura.

Paso 3 — Conecta en solo lectura

Copia el ExternalId que te da Cloura, crea el rol ClouraReadOnly (política administrada ReadOnlyAccess) con confianza hacia Cloura y pega su ARN. Pulsa Verificar conexión: si el acceso es válido, la cuenta queda lista para el primer análisis. Ninguna acción de escritura está incluida.

app.cloura.ai/onboarding
1 Nube 2 Alcance 3 Método 4 Conectar
AWSAWS · Guía por consola

Conecta tu Proveedor Cloud

Conecta una cuenta en modo solo lectura. El mismo flujo conecta cualquier Proveedor Cloud — elige uno y sigue los pasos.

ExternalId cloura-7f3a9c2e-ana-rios-prod
Esperando credenciales
Paso final: ExternalId, ARN del rol de solo lectura y "Verificar conexión".

Guías por proveedor

El asistente ejecuta todo esto por ti y rellena los valores (ExternalId, subject de federación) automáticamente. Si prefieres hacerlo a mano, aquí tienes por cada nube la conexión de una cuenta con CLI y la de toda la organización (multi-cuenta).

AWS Azure GCP

AWS Amazon Web Services

Conexión por rol de solo lectura (ClouraReadOnly con la política administrada ReadOnlyAccess), que Cloura asume mediante un ExternalId.

Cuenta individual (CLI)

Córrelo con el aws-cli autenticado en la cuenta que quieres conectar. Crea el rol, le adjunta ReadOnlyAccess e imprime el ARN para pegarlo en Cloura.

Alternativa sin instalar nada: AWS CloudShellPuedes pegar el mismo script en AWS CloudShell abierto en la cuenta que quieres conectar (icono de terminal, arriba a la derecha de la consola de AWS). Ya viene con aws-cli autenticado.
terminal · aws-cli
export AWS_PAGER=""

aws iam create-role \
  --role-name ClouraReadOnly \
  --assume-role-policy-document '{
    "Version":"2012-10-17",
    "Statement":[{
      "Effect":"Allow",
      "Principal":{"AWS":"arn:aws:iam::183124052250:root"},
      "Action":"sts:AssumeRole",
      "Condition":{"StringEquals":{"sts:ExternalId":"cloura-7f3a9c2e"}}
    }]
  }'

aws iam attach-role-policy --role-name ClouraReadOnly \
  --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess

aws iam get-role --role-name ClouraReadOnly --query Role.Arn --output text
Solo lecturaLa política ReadOnlyAccess es de AWS y no permite ningún cambio. El ExternalId lo entrega el asistente ya personalizado.

Organización completa (multi-cuenta)

Se apoya en dos roles: (1) ClouraOrgReadOnly en la cuenta de gestión (management/payer), que Cloura asume para listar las cuentas (organizations:ListAccounts); y (2) ClouraReadOnly en cada cuenta miembro (despliégalo con un StackSet usando el mismo trust). Corre este script en la cuenta de gestión y pega el ARN que imprime:

Alternativa: AWS CloudShellTambién puedes ejecutarlo desde AWS CloudShell abierto en la cuenta de gestión (management/payer) de la organización — es la cuenta donde se crea ClouraOrgReadOnly. El rol ClouraReadOnly de cada cuenta miembro se despliega aparte con el StackSet.
cloura-org-aws.sh
export AWS_PAGER=""

aws iam create-role \
  --role-name ClouraOrgReadOnly \
  --assume-role-policy-document '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::183124052250:root"},"Action":"sts:AssumeRole","Condition":{"StringEquals":{"sts:ExternalId":"cloura-7f3a9c2e"}}}]}'

aws iam attach-role-policy --role-name ClouraOrgReadOnly \
  --policy-arn arn:aws:iam::aws:policy/ReadOnlyAccess

aws iam get-role --role-name ClouraOrgReadOnly --query Role.Arn --output text
Dos piezasEl ARN que pegas es el de la cuenta de gestión (lista las cuentas). Cada cuenta miembro necesita además su propio rol ClouraReadOnly de solo lectura vía StackSet.

AZ Microsoft Azure

Conexión por federación de identidad (OIDC): una App Registration con credencial federada y los roles Reader + Cost Management Reader. Sin secretos que rotar.

Suscripción individual (CLI)

Córrelo con az autenticado en la suscripción a conectar. Crea o reutiliza la App Cloura-ReadOnly, agrega la credencial federada, asigna los roles de lectura e imprime tenant / subscription / client.

Alternativa sin instalar nada: Azure Cloud ShellPuedes pegar el script en Azure Cloud Shell con la suscripción a conectar activa (az account set --subscription <id>). Ya trae az autenticado.
terminal · az-cli
SUB_ID=$(az account show --query id -o tsv)

APP_ID=$(az ad app list --display-name Cloura-ReadOnly --query "[0].appId" -o tsv)
[ -z "$APP_ID" ] && APP_ID=$(az ad app create --display-name Cloura-ReadOnly --query appId -o tsv)

az ad sp show --id "$APP_ID" >/dev/null 2>&1 || az ad sp create --id "$APP_ID" >/dev/null
SP_ID=$(az ad sp show --id "$APP_ID" --query id -o tsv)

az ad app federated-credential list --id "$APP_ID" --query "[?name=='cloura-oidc']" -o tsv | grep -q cloura-oidc ||
az ad app federated-credential create --id "$APP_ID" --parameters '{
  "name": "cloura-oidc",
  "issuer": "https://api.cloura.ai/oidc",
  "subject": "<CLOURA_SUBJECT>",
  "audiences": ["api://AzureADTokenExchange"]
}' >/dev/null

for ROLE in Reader "Cost Management Reader"; do
  az role assignment list --assignee "$APP_ID" --role "$ROLE" --scope "/subscriptions/$SUB_ID" --query "[0].id" -o tsv | grep -q . ||
  az role assignment create --assignee-object-id "$SP_ID" --assignee-principal-type ServicePrincipal --role "$ROLE" --scope "/subscriptions/$SUB_ID" >/dev/null
done

echo "Pega en Cloura -> tenant=$(az account show --query tenantId -o tsv) subscription=$SUB_ID client=$APP_ID"
Solo lecturaReader y Cost Management Reader son roles de consulta. El subject de federación lo entrega el asistente.

Todas las suscripciones (organización)

El mismo enfoque, asignando los roles de lectura a todas las suscripciones del tenant en un solo script. No necesitas Management Group ni permisos especiales; al terminar pega tenant=… client=….

Alternativa: Azure Cloud ShellPuedes correrlo desde Azure Cloud Shell autenticado en el tenant, con una identidad que pueda asignar roles en las suscripciones (por ejemplo User Access Administrator u Owner).
cloura-org-azure.sh
TENANT_ID=$(az account show --query tenantId -o tsv)
APP_ID=$(az ad app list --display-name Cloura-ReadOnly --query "[0].appId" -o tsv)
[ -z "$APP_ID" ] && APP_ID=$(az ad app create --display-name Cloura-ReadOnly --query appId -o tsv)
az ad sp show --id "$APP_ID" >/dev/null 2>&1 || az ad sp create --id "$APP_ID" >/dev/null
SP_ID=$(az ad sp show --id "$APP_ID" --query id -o tsv)

az ad app federated-credential list --id "$APP_ID" --query "[?name=='cloura-oidc']" -o tsv | grep -q cloura-oidc ||
az ad app federated-credential create --id "$APP_ID" --parameters '{"name":"cloura-oidc","issuer":"https://api.cloura.ai/oidc","subject":"<CLOURA_SUBJECT>","audiences":["api://AzureADTokenExchange"]}' >/dev/null

for SUB in $(az account list --query "[?tenantId=='$TENANT_ID'].id" -o tsv); do
  for ROLE in Reader "Cost Management Reader"; do
    az role assignment list --assignee "$APP_ID" --role "$ROLE" --scope "/subscriptions/$SUB" --query "[0].id" -o tsv | grep -q . ||
    az role assignment create --assignee-object-id "$SP_ID" --assignee-principal-type ServicePrincipal --role "$ROLE" --scope "/subscriptions/$SUB" >/dev/null
  done
done

echo "Pega en Cloura -> tenant=$TENANT_ID client=$APP_ID"

GCP Google Cloud

Conexión por Workload Identity Federation (WIF): un pool OIDC y una service account cloura-readonly con roles de solo lectura (viewer, cloudasset.viewer, etc.).

Proyecto individual (CLI)

Córrelo con gcloud autenticado en el proyecto. Crea el WIF pool, el provider OIDC y la service account, le da los roles de lectura e imprime wif / service / project.

Alternativa sin instalar nada: Cloud Shell de GCPPuedes pegar el script en Cloud Shell con el proyecto a conectar activo (gcloud config set project <id>). Ya trae gcloud autenticado.
terminal · gcloud
PROJECT_ID=$(gcloud config get-value project 2>/dev/null)
CLOURA_SUBJECT="<CLOURA_SUBJECT>"

gcloud iam workload-identity-pools create cloura-pool --location=global --project=$PROJECT_ID 2>/dev/null

gcloud iam workload-identity-pools providers create-oidc cloura-oidc \
  --location=global --workload-identity-pool=cloura-pool --project=$PROJECT_ID \
  --issuer-uri="https://api.cloura.ai/oidc" --attribute-mapping="google.subject=assertion.sub" 2>/dev/null

gcloud iam service-accounts create cloura-readonly --project=$PROJECT_ID 2>/dev/null
SA=cloura-readonly@$PROJECT_ID.iam.gserviceaccount.com

for R in roles/viewer roles/cloudasset.viewer roles/iam.securityReviewer roles/recommender.viewer roles/monitoring.viewer; do
  gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA" --role="$R" >/dev/null
done

BA=$(gcloud billing projects describe $PROJECT_ID --format="value(billingAccountName)" 2>/dev/null)
[ -n "$BA" ] && gcloud billing accounts add-iam-policy-binding ${BA#billingAccounts/} --member="serviceAccount:$SA" --role="roles/billing.viewer" >/dev/null 2>&1

PNUM=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
gcloud iam service-accounts add-iam-policy-binding $SA --role=roles/iam.workloadIdentityUser \
  --member="principal://iam.googleapis.com/projects/$PNUM/locations/global/workloadIdentityPools/cloura-pool/subject/$CLOURA_SUBJECT" >/dev/null

echo "Pega en Cloura -> wif=//iam.googleapis.com/projects/$PNUM/locations/global/workloadIdentityPools/cloura-pool/providers/cloura-oidc service=$SA project=$PROJECT_ID"
Solo lecturaTodos los roles son de consulta; cloudasset.viewer es obligatorio para el descubrimiento de recursos.

Organización completa

Primero corre la conexión del proyecto individual (crea cloura-pool y la service account). Luego otorga el rol roles/browser a nivel de organización para descubrir todos los proyectos; pega org=… wif=… service=….

Alternativa: Cloud Shell de GCPTambién puedes ejecutarlo desde Cloud Shell, con una identidad que tenga permisos de IAM a nivel de organización (para conceder roles/browser en la organización).
cloura-org-gcp.sh
PROJECT_ID=$(gcloud config get-value project 2>/dev/null)
PNUM=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
SA=cloura-readonly@$PROJECT_ID.iam.gserviceaccount.com
ORG_ID=$(gcloud organizations list --format="value(name.basename())" | head -1)

gcloud organizations add-iam-policy-binding $ORG_ID --member="serviceAccount:$SA" --role="roles/browser" >/dev/null

echo "Pega en Cloura -> org=$ORG_ID wif=//iam.googleapis.com/projects/$PNUM/locations/global/workloadIdentityPools/cloura-pool/providers/cloura-oidc service=$SA"
© Cloura · cloura.ai