CertSafari
    Snowflake SnowPro Advanced: Security Engineer (SEA-C01)· Lessons

    Domain 5 · Lesson 19/21

    Securing Snowpark Container Services: compute pools, endpoints, egress and service identity

    Secure and govern applications with Snowpark Container Services.

    23 min read
    4% of exam
    8 sources
    Published 20 Oct 2026
    Docs as of 4 Oct 2026

    What you will be able to do

    • Explain how compute pools place service instances and containers, and which network paths are open by default
    • List the privileges a service's owner role needs, including BIND SERVICE ENDPOINT for public endpoints
    • Attach an external access integration to a service and write egress network rules that Snowpark Container Services accepts
    • Pass Snowflake secrets into containers as environment variables or files, and predict how each behaves after rotation
    • Describe how container code connects to Snowflake with the service OAuth token, and when to use caller's rights
    • Explain the security effects of service restarts, suspension, upgrades and jobs, and troubleshoot common failures with the event table and proxy behaviour
    • Trace how compute pool states, maintenance and image pinning affect which code a service runs and who can start it

    Key concept

    Default-closed service networking — A Snowpark Container Services service starts sealed in both directions: its endpoints answer only service functions and other services, and its containers have limited internet access. You open each direction separately with an explicit, privileged grant: a public endpoint for inbound traffic and an external access integration for outbound traffic.

    1.Compute pools, services and where containers run

    Snowpark Container Services is a managed container platform inside Snowflake. You package an application as an OCI image and run it next to your data, so ML training, model serving or a web app over Snowflake tables never has to move data off the platform. Three objects make this work: an image repository (created with CREATE IMAGE REPOSITORY) that holds your images, a compute pool of virtual machine nodes, and a service that runs the image on the pool.

    Services come in two kinds, and the difference matters for security later. A long-running service, created with CREATE SERVICE, behaves like a web server: if a container exits, Snowflake restarts it. A job service, started with EXECUTE JOB SERVICE, has a finite life like a stored procedure. When its containers exit the job is done, and nothing is restarted. Both need a YAML specification, which you can write inline or store on a stage. Keeping production specifications on a stage separates who writes the spec from who deploys it.

    Creating a long-running service from a specification stored on a stagesql
    CREATE SERVICE echo_service IN COMPUTE POOL tutorial_compute_pool FROM @tutorial_stage SPECIFICATION_FILE='echo_spec.yaml';

    Placement follows two rules. Instances of a service can land on the same node as other workloads or be spread across nodes. In the reference architecture, one node runs two instances of service A plus a job, and the other node runs the third instance of A alongside service B. Within a single service instance, though, every container always runs on the same node. Those co-located containers talk to each other over localhost without declaring anything. Containers in a different service, or in another instance of the same service, can only reach them through endpoints declared in the specification.

    Sharing a node does not make two services reachable from each other, because isolation comes from the network defaults. Endpoints are private unless you mark them public, and containers have limited internet access unless you attach an external access integration. Inbound and outbound are separate doors. Each one is opened by its own grant, and that model shapes the rest of this page.

    A compute pool has a lifecycle of its own, apart from the services on it. An IDLE pool has nodes but nothing scheduled, and autoscaling can shrink it to its minimum. An ACTIVE pool has at least one service running or scheduled. A SUSPENDED pool holds no nodes at all. Suspending a pool with ALTER COMPUTE POOL suspends every service except job services, which keep running until they reach DONE or FAILED and only then release their nodes. A suspended pool is not a guarantee that nothing will run: with AUTO_RESUME set to true, any role holding USAGE on the pool can wake it just by starting or resuming a service, without holding OPERATE. Control who gets USAGE, not just who gets OPERATE.

    Maintenance and restarts decide which code is running. Snowflake replaces compute pool nodes every few weeks, and each node lives for at most a month, so service instances are recreated on new nodes as a matter of routine. The replacement is rolling, never more than half the instances at a time. A single-instance service is disrupted while its instance is rebuilt, and running job services are disrupted and must be restarted by you. Setting MIN_READY_INSTANCES below 50 percent of MIN_INSTANCES keeps a multi-instance service from dropping to PENDING mid-maintenance. Every one of these recreations, like a resume or an autoscale, redeploys the image version recorded when the service was created. If you push a patched image under the same tag, a running service does not pick it up until you run ALTER SERVICE with a specification, which pulls the latest image. A known-vulnerable image can therefore keep coming back after every restart until you redeploy deliberately.

    Checkpoint 1 of 11· Fill the gap

    You are deploying a web app that Snowflake should restart automatically if its container exits. The production specification is kept on a stage so that spec authors and deployers stay separate. Which object type completes the statement?

    CREATE  ?  echo_service IN COMPUTE POOL tutorial_compute_pool FROM @tutorial_stage SPECIFICATION_FILE='echo_spec.yaml';

    Sources1234

    2.Privileges the service owner role needs

    The role that runs CREATE SERVICE becomes the service owner, and every security decision on the service is checked against it. Least-privilege design is covered under RBAC role hierarchy and least privilege (system roles, functional vs access roles). For SPCS the concrete minimum is short: a developer role with no account-level privileges needs CREATE SERVICE on the schema and USAGE on the compute pool, plus READ on whatever the specification references.

    Minimum privileges for the role that executes CREATE SERVICE
    PrivilegeObjectWhy it is needed
    CREATE SERVICESchemaThe service is a schema object
    USAGECompute poolThe service runs on the pool's nodes
    READStageOnly when the specification file is stored on a stage
    READImage repositoryPull the images the specification references
    BIND SERVICE ENDPOINTAccountOnly for services with public endpoints

    Two more grants come into play when the service talks to the outside: USAGE on any external access integration it lists, and READ on every secret its specification references. Operating on any schema object also requires at least one privilege on the parent database and schema.

    ACCOUNTADMIN still has a job here. It can create the external access integration and grant USAGE on it to the developer role. The service itself has to be owned by that narrower role.

    Checkpoint 2 of 11· Check yourself

    A developer role holds USAGE on the database and schema, CREATE SERVICE on the schema, USAGE on the compute pool, and READ on the image repository. It runs CREATE SERVICE with an inline specification that declares one endpoint with public: true and no external access integrations. What else must the role be granted for this service to work as intended?

    Checkpoint 3 of 11· Exam question

    Which privilege must the owner role of a service hold before the service can be created with an endpoint declared as public: true in its specification?

    Sources53

    3.Ingress: private endpoints, public endpoints and the proxy

    An endpoint is a port your container listens on, declared in the specification. By default it is private, so only service functions and other services can call it. Adding public: true exposes it to the internet. Snowflake then allocates a unique hostname for the endpoint and routes requests with that hostname to the service.

    Declaring a public endpoint in the service specificationyaml
    endpoints:
    - name: <endpoint name>
      port: <port number>
      protocol : < TCP / HTTP >
      public: true

    Making an endpoint public is a privileged operation. The owner role must hold BIND SERVICE ENDPOINT on the account, and the check doesn't stop at creation. If the owner role later loses the privilege, the public endpoints stop being accessible. Revoking that one grant is therefore a way to take every public endpoint owned by a role offline without dropping any services. Users who reach a public endpoint authenticate to Snowflake, and a web app can send them to /sfc-endpoint/logout so they have to re-authenticate.

    Public traffic never reaches the container directly. A Snowflake proxy sits in front of it and applies these rules in both directions:

    • Requests using TRACE or CONNECT are not forwarded.
    • Request headers X-SF-SPCS-Authorization, and Authorization when it carries a Snowflake token, are stripped, so the container never sees the user's Snowflake credential.
    • Responses whose Content-Type marks an executable or shell script (for example application/x-sh) are replaced with a 403.
    • X-Frame-Options is set to DENY, COOP and CORP to same-origin, and X-Content-Type-Options to nosniff, while Server and X-Powered-By are removed.
    • A Content-Security-Policy header is added, and when the service uses an external access integration, the CSP allows the same destinations, so the browser page can reach only what the service itself can reach.

    CORS is configured in the specification's corsSettings, not in your code. The proxy returns the configured settings and removes any CORS headers your service sends. Ingress connections also close after 90 seconds without activity, so long-lived clients need polling or WebSockets.

    Checkpoint 4 of 11· Check yourself

    A web app works in local testing, where its code sets Access-Control-Allow-Origin headers. After it is deployed to SPCS with a public endpoint, cross-origin calls from the partner site fail. The endpoint in the specification has no corsSettings. What explains this, and where is it fixed?

    Sources35

    4.Egress: attaching external access integrations to a service

    Outbound and inbound use different controls. Network policies govern ingress to your account. Egress from containers is governed only by external access integrations (EAIs), which are listed in the service's EXTERNAL_ACCESS_INTEGRATIONS property on CREATE SERVICE or EXECUTE JOB SERVICE. An EAI wraps egress network rules (Network rules (TYPE and MODE); creating and granting the integration itself is covered in External access integrations). If a service's outbound calls fail with connection errors, adding IPs to a network policy will not help, and neither will a field in the container YAML. The fix is an EGRESS rule, inside an EAI, listed on the service.

    An egress rule for exactly one host; with no port given, 443 is assumedsql
    CREATE OR REPLACE NETWORK RULE translate_network_rule MODE = EGRESS TYPE = HOST_PORT VALUE_LIST = ('translation.googleapis.com');
    Attaching the integration to a long-running servicesql
    CREATE SERVICE eai_service IN COMPUTE POOL MYPOOL EXTERNAL_ACCESS_INTEGRATIONS = (GOOGLE_APIS_ACCESS_INTEGRATION)

    SPCS adds its own constraints on top of ordinary network rules, and both are checked when the service is created:

    • Each VALUE_LIST entry must be a full host name. Wildcards such as *.googleapis.com are rejected, so every subdomain is listed separately.
    • Only ports 22, 80, 443 and 1024 and above are allowed. If a referenced rule allows any other port, service creation fails.
    • 0.0.0.0 opens HTTP and HTTPS to the whole internet, and only on ports 80 or 443. It is the opposite of least privilege, so use it deliberately.

    Here is how a draft rule fares against those checks. db.vendor.example.com:5432 is valid, since 5432 is above 1024. api.vendor.example.com:443 is valid. smtp.vendor.example.com:25 makes CREATE SERVICE fail on the port, and *.vendor.example.com:443 fails on the wildcard. To keep traffic off the public internet, create a rule with TYPE = PRIVATE_HOST_PORT that points at a private connectivity endpoint. The EAI and service steps stay the same, but Snowflake and the target must be on the same cloud provider and in the same region.

    Checkpoint 5 of 11· Match them up

    A platform team is reviewing draft VALUE_LIST entries for an egress network rule. The rule will go in an external access integration that a new SPCS service lists. Match each entry to what happens when the service is created.

    Tap a term, then the definition that fits it.

    Checkpoint 6 of 11· Exam question

    A service running in a compute pool must call https://api.partner.example.com:443 to enrich records, but outbound calls fail with connection errors. Security wants egress limited to that single host. What should the administrator do?

    Checkpoint 7 of 11· Exam question

    A security engineer is drafting the VALUE_LIST for a network rule (MODE = EGRESS, TYPE = HOST_PORT) that will back an external access integration for a service. Which TWO entries are valid for Snowpark Container Services egress?(Select 2)

    0 of 2 selected

    Sources13

    5.Getting secrets into containers without putting them in YAML

    A specification names a secret but never contains its value. In the containers.secrets field you reference a Snowflake secret object by its fully qualified name, and Snowflake delivers the value at runtime. The secret types themselves are covered in Snowflake secrets (password, generic string, OAuth, cloud provider token). The owner role needs READ on each referenced secret.

    Mapping a password secret's fields to environment variablesyaml
    containers:
    - name: main
      image: <url>
      secrets:
      - snowflakeSecret: testdb.testschema.my_secret_object
        secretKeyRef: username
        envVarName: LOGIN_USER
      - snowflakeSecret: testdb.testschema.my_secret_object
        secretKeyRef: password
        envVarName: LOGIN_PASSWORD

    The alternative is directoryPath, which writes the secret as files. A password secret becomes username and password files, a generic string becomes secret_string, and an OAuth secret becomes access_token.

    Rotation therefore decides the delivery method. If credentials rotate on a schedule, mount them with directoryPath and have the code re-read the file. OAuth secrets add one more condition: they exist to reach an internet destination, so the secret must be listed in an EAI's ALLOWED_AUTHENTICATION_SECRETS, and that EAI must be attached to the service. Otherwise CREATE SERVICE or EXECUTE JOB SERVICE fails. Password and generic string secrets don't have this requirement.

    Checkpoint 8 of 11· Fill the gap

    The database team rotates the password in my_secret_object every 30 days. The service must pick up each new password without being recreated, and its code will read the credential from disk. Which field completes the specification?

    containers:
    - name: main
      image: <url>
      secrets:
      - snowflakeSecret: testdb.testschema.my_secret_object
         ? : '/usr/local/creds'

    Sources2

    6.Service identity and secure data access

    A container gets a Snowflake identity without any stored credential. When a service or job starts, Snowflake writes an OAuth token to /snowflake/session/token and sets SNOWFLAKE_ACCOUNT and SNOWFLAKE_HOST. Container code uses all three to connect through a normal Snowflake driver, authenticating as the service user. The token cannot be used outside Snowpark Container Services, or without SNOWFLAKE_HOST, so a token copied out of a container is of no use elsewhere. The sessionTokenConfig spec field can move the token or tighten its file permission mode.

    Running every query as the service suits pipelines and model serving. It's the wrong fit for an API or web UI that many people use, because each of them would see whatever the service can see. Caller's rights solve this, so that queries run with the end user's permissions. Set executeAsCaller: true in the specification's capabilities.securityContext to declare the intent. It is off by default.

    Declaring caller's rights in the specificationyaml
    capabilities:
      securityContext:
        executeAsCaller: <true / false>    # optional, indicates whether application intends to use caller's rights

    Callers are scoped with service roles. The top-level serviceRoles field defines named roles, and each one lists the endpoints it covers, so you can grant access to one endpoint, such as an admin UI, without granting the others. For auditing, queries the container issues with its token run as the service user. That is the identity to filter on when you trace an AI/ML workload's reads and writes in ACCESS_HISTORY (direct vs base objects, columns, writes).

    Checkpoint 9 of 11· Check yourself

    Analysts use an internal web UI on SPCS to look at sales data. Their Snowflake roles grant different levels of access. Right now the container's code connects with the OAuth token Snowflake writes to /snowflake/session/token, so every analyst sees the same results. How should the service be changed so each analyst sees only what their own role allows?

    Sources617

    7.Lifecycle: restarts, suspension, upgrades and jobs

    A long-running service keeps restarting. When a container crashes, Snowflake brings it back, so a container that keeps failing because of a revoked secret or a missing grant will keep restarting rather than stay down. A job service is the opposite: its containers are never restarted, and its status ends at DONE, FAILED or CANCELLED. A job is the better fit for one-off training runs that need broad data access only for a short time.

    Lifecycle operations and their security effect
    OperationWhat Snowflake doesSecurity consequence
    ALTER SERVICE … SUSPEND / DROP SERVICETerminates all service instancesImmediate way to stop a misbehaving service
    ALTER SERVICE with a new specificationRolling upgrade, one instance at a timeOld and new code briefly serve side by side
    Instance terminationSIGTERM, then a 30-second grace windowCode should flush and close connections in that window
    Auto-suspensionNot supported for jobs or services with public endpointsPublic services keep running until you suspend them
    ALTER on a job serviceNot allowedCancel and re-run a job instead of patching it

    The auto-suspension rule catches people out. Snowflake decides a service is idle by watching service function traffic only, not ingress. A public web app therefore never looks idle and is never suspended for you. Suspending it, and revoking BIND SERVICE ENDPOINT if needed, is an explicit operational step.

    Checkpoint 10 of 11· Check yourself

    For a one-off model training run, a data science team needs a role with broad read access to sensitive tables. That access should only be in use while the training runs. When the training code finishes and its container exits, nothing should come back up and read the data again. How should they run the workload?

    Sources2

    8.Monitoring and troubleshooting security issues

    Container output goes to the account's event table, which is where service troubleshooting starts (the table itself and SIEM export are covered in Event tables and external observability/SIEM integration). Each log row's RESOURCE_ATTRIBUTES identifies the service, container and compute pool, so you filter on snow.service.name. Always bound the query by timestamp, because the table holds events from many Snowflake components.

    Container logs for one service over the last hoursql
    SELECT TIMESTAMP, RESOURCE_ATTRIBUTES, RECORD_ATTRIBUTES, VALUE
    FROM <current_event_table_for_your_account>
    WHERE timestamp > dateadd(hour, -1, current_timestamp())
    AND RESOURCE_ATTRIBUTES:"snow.service.name" = '<service_name>'
    AND RECORD_TYPE = 'LOG'
    ORDER BY timestamp DESC
    LIMIT 10;

    Many SPCS security problems never show up in container logs, because the platform enforces them before or after your code runs. Things that work in local Docker testing can fail once deployed, since the local setup has no proxy. Match the symptom to the control:

    Symptoms caused by SPCS security controls
    SymptomCauseFix
    Outbound calls fail with connection errorsNo EAI on the service, or the host is missing from its rulesAdd an EGRESS HOST_PORT rule to an EAI listed in EXTERNAL_ACCESS_INTEGRATIONS
    CREATE SERVICE fails after adding an EAIA referenced rule allows a port outside 22, 80, 443, 1024+Narrow the rule's ports
    CORS headers set by the app never reach the browserThe proxy removes service-sent CORS headersConfigure corsSettings in the specification
    Browser download returns 403Response Content-Type marks an executableServe a non-executable MIME type
    TRACE requests never reach the containerBanned HTTP method at the proxyExpected behaviour; use another method

    A public endpoint that suddenly becomes unreachable while the service is still running usually means the owner role has lost BIND SERVICE ENDPOINT. Check that grant before you check the container.

    Checkpoint 11 of 11· Match them up

    None of these problems in a deployed SPCS service shows up as an error in the container logs, and each one worked fine in local Docker testing. Match each symptom to the platform control behind it.

    Tap a term, then the definition that fits it.

    Sources83

    Sources

    (8)

    Every claim above is drawn from one of these pages, quoted as it was written on the date shown.

    1. 1.
      “Your services, including job services, run in a compute pool, which is a collection of one or more virtual machine (VM) nodes.”
      ↩︎ Compute pools, services and where containers run
      “Snowflake doesn’t restart any job service containers.”
      ↩︎ Compute pools, services and where containers run
      “External access integration for network egress”
      ↩︎ Egress: attaching external access integrations to a service
      “Caller’s rights ensure that queries run with the correct user permissions.”
      ↩︎ Service identity and secure data access
      “Users interact with the service rather than raw data. Caller’s rights ensure that queries run with the correct user permissions.”
      ↩︎ Checkpoint
      “When all containers exit, the job service is done. Snowflake doesn’t restart any job service containers.”
      ↩︎ Checkpoint
    2. 2.
      “all containers within a single service instance always run on the same compute pool node.”
      ↩︎ Compute pools, services and where containers run
      “Snowflake might run them on the same node or distribute them across multiple nodes.”
      ↩︎ Compute pools, services and where containers run
      “you can apply the separation of concerns design principle and upload the specification to a stage”
      ↩︎ Compute pools, services and where containers run
      “Snowflake deploys that same image version in the following scenarios, even if the image in the repository has been updated:”
      ↩︎ Compute pools, services and where containers run
      “Note that Snowflake does not update secrets passed as environment variables after a service is created.”
      ↩︎ Getting secrets into containers without putting them in YAML
      “An oauth secret must be allowed by External Access Integration (EAI); otherwise CREATE SERVICE or EXECUTE JOB SERVICE will fail.”
      ↩︎ Getting secrets into containers without putting them in YAML
      “access_token if the Snowflake secret is of the oauth2 type.”
      ↩︎ Getting secrets into containers without putting them in YAML
      “Snowflake applies rolling upgrades by terminating and redeploying one service instance at a time.”
      ↩︎ Lifecycle: restarts, suspension, upgrades and jobs
      “Auto-suspension is not supported on services with public endpoints because Snowflake currently only tracks service function traffic and not ingress traffic”
      ↩︎ Lifecycle: restarts, suspension, upgrades and jobs
      “The container has the option to process the signal and shut down gracefully with a 30-second window.”
      ↩︎ Lifecycle: restarts, suspension, upgrades and jobs
      “Snowflake deploys that same image version in the following scenarios, even if the image in the repository has been updated:”
      ↩︎ Exam trap 1
      “After a service is created, if the Snowflake secret object is updated, Snowflake will update the corresponding secret files in the running containers.”
      ↩︎ Exam trap 5
    3. 3.
      “these containers can communicate with each other over localhost (there is no need to define endpoints in the service specification).”
      ↩︎ Compute pools, services and where containers run
      “By default, services have limited permissions to access the internet.”
      ↩︎ Compute pools, services and where containers run
      “The owner role that is creating the service needs the USAGE privilege on the EAI and READ privilege on the secrets referenced.”
      ↩︎ Privileges the service owner role needs
      “Note that you cannot use the ACCOUNTADMIN role to create a service.”
      ↩︎ Privileges the service owner role needs
      “Creating a public endpoint is a privileged operation and the service’s owner role must have the BIND SERVICE ENDPOINT privilege on the account.”
      ↩︎ Ingress: private endpoints, public endpoints and the proxy
      “Snowflake proxy removes the following request headers if present: X-SF-SPCS-Authorization”
      ↩︎ Ingress: private endpoints, public endpoints and the proxy
      “the proxy applies the same network rules from the EAI to the CSP for the web page.”
      ↩︎ Ingress: private endpoints, public endpoints and the proxy
      “Note that the proxy removes any CORS headers returned by the service.”
      ↩︎ Ingress: private endpoints, public endpoints and the proxy
      “Ingress endpoints have a timeout of 90 seconds.”
      ↩︎ Ingress: private endpoints, public endpoints and the proxy
      “For the VALUE_LIST parameter, you must provide a full host name. Wildcards (for example, *.googleapis.com) are not supported.”
      ↩︎ Egress: attaching external access integrations to a service
      “If a network rule referenced allows access to other ports, creation of the service will fail.”
      ↩︎ Egress: attaching external access integrations to a service
      “Only ports 80 or 443 are supported with “0.0.0.0”.”
      ↩︎ Egress: attaching external access integrations to a service
      “The TYPE parameter value is set to PRIVATE_HOST_PORT.”
      ↩︎ Egress: attaching external access integrations to a service
      “When you test a service locally, you are not using the Snowflake proxy”
      ↩︎ Monitoring and troubleshooting security issues
      “By default, service endpoints are private. Only service functions and service-to-service communications can make requests to the private endpoints.”
      ↩︎ Key concept
      “Note that you cannot use the ACCOUNTADMIN role to create a service.”
      ↩︎ Exam trap 2
      “Snowpark Container Services supports only the network rules that allow ports 22, 80, 443, and 1024+.”
      ↩︎ Exam trap 4
      “Creating a public endpoint is a privileged operation and the service’s owner role must have the BIND SERVICE ENDPOINT privilege on the account.”
      ↩︎ Checkpoint
      “The Snowflake proxy returns the CORS settings defined in the service specification. Note that the proxy removes any CORS headers returned by the service.”
      ↩︎ Checkpoint
      “Snowpark Container Services supports only the network rules that allow ports 22, 80, 443, and 1024+.”
      ↩︎ Checkpoint
      “The proxy sends a 403 response to the client if the Content-Type header in the response indicates that the response contains an executable.”
      ↩︎ Checkpoint
    4. 4.
      “When you suspend a compute pool, Snowflake suspends all services except the job services.”
      ↩︎ Compute pools, services and where containers run
      “a role with USAGE permission on the compute pool can implicitly trigger the compute pool’s resumption”
      ↩︎ Compute pools, services and where containers run
      “No more than 50 percent of the service instances are replaced at a time.”
      ↩︎ Compute pools, services and where containers run
      “Ongoing job services will be disrupted and must be restarted by customers after maintenance is complete.”
      ↩︎ Compute pools, services and where containers run
    5. 5.
      “Operating on an object in a schema requires at least one privilege on the parent database and at least one privilege on the parent schema.”
      ↩︎ Privileges the service owner role needs
      “If the service’s owner role loses this privilege, the public endpoints will not be accessible.”
      ↩︎ Ingress: private endpoints, public endpoints and the proxy
      “If the service’s owner role loses this privilege, the public endpoints will not be accessible.”
      ↩︎ Exam trap 3
    6. 6.
      “Provides credentials (an OAuth token) in the container in a file that is named /snowflake/session/token.”
      ↩︎ Service identity and secure data access
      “This OAuth token can’t be used outside Snowpark Container Services.”
      ↩︎ Service identity and secure data access
      “The OAuth token can’t be used without also using SNOWFLAKE_HOST.”
      ↩︎ Service identity and secure data access
    7. 7.
      “use the securityContext.executeAsCaller field to indicate the application intends to use caller’s rights.”
      ↩︎ Service identity and secure data access
      “For each service role, provide a name and a list of one or more endpoints”
      ↩︎ Service identity and secure data access
    8. 8.
      “RESOURCE_ATTRIBUTES: Provides a JSON object that identifies the Snowflake service and the container in the service that generated the log message.”
      ↩︎ Monitoring and troubleshooting security issues
      “Snowflake recommends that you include a timestamp in the WHERE clause of event table queries”
      ↩︎ Monitoring and troubleshooting security issues

    Spotted a mistake, or was something unclear? Tell us.