Developing functions in Functions Framework and deploying them in Yandex Serverless Containers

The folder specified in the CLI profile is used by default. You can specify a different folder using the --folder-name or --folder-id parameters.

1. Create a service account named serverless-containers-sa:

   yc iam service-account create \
     --name serverless-containers-sa
   

   Result:

   done (1s)
   id: aje7tnmd885t********
   folder_id: b1gt6g8ht345********
   created_at: "2025-02-14T11:09:54.376880905Z"
   name: serverless-containers-sa
   

   Save the service account ID (the id field value) and the folder ID (the folder_id field value), you will need them in the next step.

   For more information about the yc iam service-account create command, see the CLI reference.

2. Assign the container-registry.images.puller role for the folder to the created service account by specifying the folder and service account IDs you saved in the previous step:

   yc resource-manager folder add-access-binding <folder_ID> \
     --role container-registry.images.puller \
     --subject serviceAccount:<service_account_ID>
   

   Result:

   done (2s)
   effective_deltas:
     - action: ADD
       access_binding:
        role_id: container-registry.images.puller
         subject:
           id: aje7tnmd885t********
           type: serviceAccount
   

   For more information about the yc resource-manager folder add-access-binding command, see the CLI reference.

To create a service account, use the create REST API method for the ServiceAccount resource or the ServiceAccountService/Create gRPC API call.

To assign the service account a role for the folder, use the updateAccessBindings REST API method for the Folder resource or the FolderService/UpdateAccessBindings gRPC API call.

Create the functions-framework-registry registry:

yc container registry create \
  --name functions-framework-registry

Result:

done (1s)
id: crpfn9p374a3********
folder_id: b1gt6g8ht345********
name: functions-framework-registry
status: ACTIVE
created_at: "2025-02-14T11:44:23.698Z"

Save the ID (the id field value) of the created registry, you will need it later.

For more information about the yc container registry create command, see the CLI reference.

To create a registry, use the create method for the Registry resource or the RegistryService/Create gRPC API call.

To create a function in Python:

1. Install Python and pip:

   sudo apt update && \
   sudo apt install python3 python3-pip -y
   

2. Create a directory for the new project:

   mkdir my-first-function && \
   cd my-first-function
   

3. Install the Functions Framework:

   sudo pip install functions-framework
   

4. Create the main.py file with the function code by opening it in the text editor:

   nano main.py
   

5. Add this code to the main.py file:

   import flask
   import functions_framework
   
   @functions_framework.http
   def helloWorld(request: flask.Request) -> flask.typing.ResponseReturnValue:
       return "Hello, World!"
   

6. Run your function locally to make sure everything works correctly:

   1. Run the function:

      functions-framework --target helloWorld --debug
      

      Result:

      * Serving Flask app 'hello'
      * Debug mode: on
      WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
      * Running on all addresses (0.0.0.0)
      * Running on http://127.0.0.1:8080
      * Running on http://192.168.1.15:8080
      Press CTRL+C to quit
      * Restarting with watchdog (inotify)
      * Debugger is active!
      * Debugger PIN: 817-187-***
      

   2. Open an additional terminal window and run the following command in it:

      curl http://localhost:8080/
      

      Result:

      Hello, World!
      

   This way, you can also run a function in debug mode and use breakpoints with modern IDEs.

To create a function in Go:

1. Install Go 1.18 or higher.

2. Create a directory for the new project:

   mkdir my-first-function && \
   cd my-first-function
   

3. Create a new module:

   go mod init example.com/helloWorld
   

4. Create the function.go file with the function code by opening it in the text editor:

   nano function.go
   

5. Add this code to the function.go file:

   package function
   
   import (
     "fmt"
     "net/http"
   
     "github.com/GoogleCloudPlatform/functions-framework-go/functions"
   )
   
   func init() {
     functions.HTTP("helloWorld", helloWorld)
   }
   
   // helloWorld writes "Hello, World!" to the HTTP response.
   func helloWorld(w http.ResponseWriter, r *http.Request) {
     fmt.Fprintln(w, "Hello, World!")
   }
   

6. Run your function locally to make sure everything works correctly:

   1. Create a directory named cmd:

      mkdir cmd
      

   2. In the cmd directory, create a file named main.go:

      nano cmd/main.go
      

   3. Add this code to the main.go file:

      package main
      
      import (
        "log"
        "os"
      
        // Blank-import the function package so the init() runs
        _ "example.com/helloWorld"
        "github.com/GoogleCloudPlatform/functions-framework-go/funcframework"
      )
      
      func main() {
        // Use PORT environment variable, or default to 8080.
        port := "8080"
        if envPort := os.Getenv("PORT"); envPort != "" {
          port = envPort
        }
        
        // By default, listen on all interfaces. If testing locally, run with 
        // LOCAL_ONLY=true to avoid triggering firewall warnings and 
        // exposing the server outside of your own machine.
        hostname := ""
        if localOnly := os.Getenv("LOCAL_ONLY"); localOnly == "true" {
          hostname = "127.0.0.1"
        } 
        if err := funcframework.StartHostPort(hostname, port); err != nil {
          log.Fatalf("funcframework.StartHostPort: %v\n", err)
        }
      }
      

   4. Update the dependencies:

      go mod tidy
      

   5. Start your local server:

      FUNCTION_TARGET=helloWorld \
      LOCAL_ONLY=true \
      go run cmd/main.go
      

   6. Open an additional terminal window and run the following command in it:

      curl http://localhost:8080/
      

      Result:

      Hello, World!
      

   This way, you can also run a function in debug mode and use breakpoints with modern IDEs.

1. Create a my-first-function container:

   yc serverless container create \
     --name my-first-function
   

   Result:

   done (1s)
   id: bba0tc5nv6j0********
   folder_id: b1gt6g8ht345********
   created_at: "2025-02-14T15:26:04.744Z"
   name: my-first-function
   url: https://bba0tc5nv6j0********.containers.yandexcloud.net/
   status: ACTIVE
   

   Save the container invocation url, you will need it to test function in the container.

   For more information about the yc serverless container create command, see the CLI reference.

2. Create a revision of the container you created previously:

   yc serverless container revision deploy \
     --container-name my-first-function \
     --image "cr.yandex/<registry_ID>/my-first-function:some-tag" \
     --service-account-id <service_account_ID> \
     --no-logging
   

   Where:

   • <registry_ID>: ID of the Container Registry registry you saved in the previous step.
   • <service_account_ID>: ID of the serverless-containers-sa service account you saved in the previous step.
   • --no-logging: Disables writing logs to the log group. Remove this parameter from the command to write container execution logs. You will be charged for writing and storing logs.

   Result:

   done (16s)
   id: bba6f1jllc3t********
   container_id: bbakbil5lg7j********
   created_at: "2025-02-14T20:48:06.424Z"
   image:
     image_url: cr.yandex/crpfn9p374a3********/my-first-function:some-tag
     image_digest: sha256:1b8bac8da5e64dd4359f81d71a7803f212af385f9718a7a4f9a40bca********
   resources:
     memory: "134217728"
     cores: "1"
     core_fraction: "100"
   execution_timeout: 3s
   concurrency: "1"
   service_account_id: aje7tnmd885t********
   status: ACTIVE
   log_options:
     disabled: true
     folder_id: b1gt6g8ht345********
   runtime:
     http: {}
   

   For more information about the yc serverless container revision deploy command, see the CLI reference.

To create a container, use the create REST API method for the Container resource or the ContainerService/Create gRPC API call.

To create a container revision, use the deployRevision REST API method for the Container resource or the ContainerService/DeployRevision gRPC API call.