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.
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.
No. Containers in the same service instance always run on the same node and can reach each other over localhost. An endpoint is needed only for traffic from other services, other instances, service functions or (if public) the internet.
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';CREATE SERVICE makes a long-running service, and Snowflake restarts its containers if they exit. A job service is started with EXECUTE JOB SERVICE, has a finite life and is never restarted. The compute pool and the image repository are the objects the service runs on and pulls its image from. Neither of them runs a specification.
Source: docs.snowflake.com2.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.
| Privilege | Object | Why it is needed |
|---|---|---|
| CREATE SERVICE | Schema | The service is a schema object |
| USAGE | Compute pool | The service runs on the pool's nodes |
| READ | Stage | Only when the specification file is stored on a stage |
| READ | Image repository | Pull the images the specification references |
| BIND SERVICE ENDPOINT | Account | Only 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?
A public endpoint is a privileged ingress operation, so the owner role needs BIND SERVICE ENDPOINT on the account. READ on a stage is needed only when the specification is stored on a stage, and an external access integration controls outbound traffic, not inbound.
“Creating a public endpoint is a privileged operation and the service’s owner role must have the BIND SERVICE ENDPOINT privilege on the account.”Source: docs.snowflake.com
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?
Correct answer: A — BIND SERVICE ENDPOINT, granted at the account level to the role that will own the new service.
- A. Correct: exposing an endpoint to the internet is gated by the BIND SERVICE ENDPOINT privilege on the owner role, so public exposure is an explicit grant.
- B. Incorrect: CREATE INTEGRATION is for integration objects such as external access integrations, and it does not control public ingress endpoints.
- C. Incorrect: OPERATE on a compute pool permits suspending and resuming the pool; it does not authorize binding a public endpoint.
- D. Incorrect: MONITOR on an image repository relates to viewing repository information and has no role in enabling public endpoints.
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.
endpoints:
- name: <endpoint name>
port: <port number>
protocol : < TCP / HTTP >
public: trueMaking 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
TRACEorCONNECTare not forwarded. - Request headers
X-SF-SPCS-Authorization, andAuthorizationwhen it carries a Snowflake token, are stripped, so the container never sees the user's Snowflake credential. - Responses whose
Content-Typemarks an executable or shell script (for exampleapplication/x-sh) are replaced with a 403. X-Frame-Optionsis set toDENY, COOP and CORP tosame-origin, andX-Content-Type-Optionstonosniff, whileServerandX-Powered-Byare 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?
For public endpoints, CORS is configured in the specification. The proxy returns the corsSettings defined there and removes any CORS headers the container sends, so the app's own headers never reach the browser. An external access integration controls outbound traffic, and X-Frame-Options blocks iframe embedding, not CORS.
“The Snowflake proxy returns the CORS settings defined in the service specification. Note that the proxy removes any CORS headers returned by the service.”Source: docs.snowflake.com
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.
CREATE OR REPLACE NETWORK RULE translate_network_rule MODE = EGRESS TYPE = HOST_PORT VALUE_LIST = ('translation.googleapis.com');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_LISTentry must be a full host name. Wildcards such as*.googleapis.comare 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.0opens 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.
SPCS checks each referenced egress rule when the service is created. Every entry must be a full host name with no wildcards, and only ports 22, 80, 443 and 1024 and above are allowed, so port 25 fails. The 0.0.0.0 entry is valid on port 80 or 443, but it opens egress to the whole internet, which is the opposite of least privilege.
“Snowpark Container Services supports only the network rules that allow ports 22, 80, 443, and 1024+.”Source: docs.snowflake.com
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?
Correct answer: A — Create an EGRESS HOST_PORT network rule for api.partner.example.com:443, wrap it in an external access integration, and list it in the service's EXTERNAL_ACCESS_INTEGRATIONS.
- A. Correct: services have no outbound access by default, and egress is opened by an EGRESS HOST_PORT network rule packaged in an external access integration that CREATE SERVICE references. This limits calls to the single named host and port.
- B. Incorrect: account-level network policies govern inbound client connections to Snowflake, not outbound traffic from containers. Restarting the service does not change that.
- C. Incorrect: egress rules use MODE = EGRESS, not INGRESS, and network rules are not attached to compute pools. Egress is bound per service through the integration.
- D. Incorrect: the specification YAML has no allowedHosts field, and a network rule alone does nothing until it is placed inside an external access integration referenced by the service.
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)
Correct answers: A, C — 'api.vendor.example.com:443' to allow HTTPS calls to exactly one fully named vendor host.; 'db.vendor.example.com:5432' to allow outbound connections to a PostgreSQL server on a high port.
- A. Correct: a fully qualified hostname with an allowed port is the standard HOST_PORT form, and port 443 is permitted for egress.
- B. Incorrect: wildcards are not supported in SPCS egress host lists, so every hostname must be written out in full.
- C. Correct: egress permits ports 22, 80, 443 and anything from 1024 upward, so a database on port 5432 can be allowed by hostname.
- D. Incorrect: port 25 is outside the permitted set of 22, 80, 443 and 1024 and above, so this entry cannot be used for container egress.
- E. Incorrect: SPCS egress relies on HOST_PORT rules naming hostnames and ports; a CIDR-style IPV4 rule is not how container egress is granted.
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.
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_PASSWORDThe 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'directoryPath writes the secret as username and password files, and Snowflake refreshes those files in running containers when the secret changes. A secret delivered through envVarName (with secretKeyRef choosing the field) keeps the value it had when the service was created, so it would go stale after rotation. mountPath is not a containers.secrets field.
Source: docs.snowflake.comSources2
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.
capabilities:
securityContext:
executeAsCaller: <true / false> # optional, indicates whether application intends to use caller's rightsCallers 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?
Queries made with the service's own token run as the service user, so every caller sees whatever the service can see. For an API or web UI with many users, caller's rights make queries run with the end user's permissions. Secrets hold credentials for outside systems, a private endpoint only changes who can reach the service, and the token cannot be used outside SPCS.
“Users interact with the service rather than raw data. Caller’s rights ensure that queries run with the correct user permissions.”Source: docs.snowflake.com
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.
| Operation | What Snowflake does | Security consequence |
|---|---|---|
| ALTER SERVICE … SUSPEND / DROP SERVICE | Terminates all service instances | Immediate way to stop a misbehaving service |
| ALTER SERVICE with a new specification | Rolling upgrade, one instance at a time | Old and new code briefly serve side by side |
| Instance termination | SIGTERM, then a 30-second grace window | Code should flush and close connections in that window |
| Auto-suspension | Not supported for jobs or services with public endpoints | Public services keep running until you suspend them |
| ALTER on a job service | Not allowed | Cancel 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?
A job service has a finite life. When all its containers exit, the job is done and nothing is restarted. That makes it the right fit for short-lived runs that need broad data access. A long-running service created with CREATE SERVICE restarts any container that exits, so the training code would run again with the same access until someone suspends or drops the service.
“When all containers exit, the job service is done. Snowflake doesn’t restart any job service containers.”Source: docs.snowflake.com
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.
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:
| Symptom | Cause | Fix |
|---|---|---|
| Outbound calls fail with connection errors | No EAI on the service, or the host is missing from its rules | Add an EGRESS HOST_PORT rule to an EAI listed in EXTERNAL_ACCESS_INTEGRATIONS |
| CREATE SERVICE fails after adding an EAI | A referenced rule allows a port outside 22, 80, 443, 1024+ | Narrow the rule's ports |
| CORS headers set by the app never reach the browser | The proxy removes service-sent CORS headers | Configure corsSettings in the specification |
| Browser download returns 403 | Response Content-Type marks an executable | Serve a non-executable MIME type |
| TRACE requests never reach the container | Banned HTTP method at the proxy | Expected 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.
These controls are enforced by the platform outside your code, so you won't find them in the container logs. Outbound traffic needs an EGRESS rule inside an external access integration that the service lists. The ingress proxy refuses TRACE and CONNECT and sends a 403 in place of any response with an executable MIME type. A public endpoint stays reachable only while the owner role holds BIND SERVICE ENDPOINT.
“The proxy sends a 403 response to the client if the Content-Type header in the response indicates that the response contains an executable.”Source: docs.snowflake.com
Sources
(8)
Every claim above is drawn from one of these pages, quoted as it was written on the date shown.
- 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“Network policies for network ingress”
↩︎ Egress: attaching external access integrations to a service“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.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/working-with-servicesOfficial docs
“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.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/service-network-communicationsOfficial docs
“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.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/working-with-compute-poolOfficial docs
“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.
“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.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/spcs-execute-sqlOfficial docs
“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.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/specification-referenceOfficial docs
“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.https://docs.snowflake.com/en/developer-guide/snowpark-container-services/monitoring-servicesOfficial docs
“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