Overview

Private service is a running container with a private endpoint(only accessible by resources of you stack). Main features of private service are:

• scalability - automatically add/remove containers based on CPU or memory usage (within your specified thresholds),
• zero downtime deployments,
• multiple options to provide container image, including zero-config packaging of code for Typescript/Javascript, Python, Java and Go,
• no hassle with managing and patching servers or VMs,
• seamless connectivity with other resources.

Under the hood

Under the hood Stacktape uses AWS ECS(Elastic Container Service) to orchestrate your containers. Containers can be ran using Fargate or EC2 instances:

• Fargate - technology which allows you to run containers without having to manage servers or clusters. This means you don't have to worry about administration tasks such as scaling, VM security, OS security & much more.
• EC2 instances - VMs running on AWS

ECS Services are self healing - if your container instance dies for any reason, it is automatically replaced with a healthy instance. They auto-scale from the box(within configured boundaries) leveraging the AWS Application Auto Scaling service.

Private-service provides two load balancing modes. Based on which mode you use, different underlying mechanisms are used underneath:

• If you use service-connect load balancing (default), ECS Service Connect technology is used. In this mode, private endpoint is only available to other ECS-based resources (web-services, worker-services,multi-container-workloads).

• If you use application-load-balancer load balancing, AWS Application Load Balancer is used. In this mode, private endpoint is available to all the resources in your VPC.

• See also sections Load balancing and Connecting to a Private Service.

When to use

If you are unsure which resource type is best suitable for your app, following table provides short comparison of all container-based resource types offered by Stacktape.

Advantages

• Control over underlying environment - Private service can run any Docker image or image built using your own Dockerfile.
• Price for compute resources with predictable load - Compared to functions, private services are cheaper if your compute resource has a predictable load.
• Load-balanced and auto-scalable - Private services can automatically horizontally scale based on the CPU and Memory utilization.
• High availability - Private services run in multiple Availability Zones.
• Secure by default - Underlying environment is securely managed by AWS.

Disadvantages

• Scaling speed - Unlike lambda functions that scale almost instantly, private service requires more time - from several seconds to few minutes to add another container.

• Not fully serverless - While private services can automatically scale up and down, they can't scale to 0. This means, if your compute resource is unused, you are still paying for at least one instance (minimum ~$8/month)

Basic usage

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/main.ts
      resources:
        cpu: 2
        memory: 2048

Copy
import express from 'express';

const app = express();

app.get('/', async (req, res) => {
  res.send({ message: 'Hello' });
});

// for your app use port number stored in PORT environment variable for your application
// this environment variable is automatically injected by Stacktape
app.listen(process.env.PORT, () => {
  console.info(`Server running on port ${process.env.PORT}`);
});

Connecting to a Private Service

Private services do not have publicly accessible HTTPS URLs.

Instead, they have service address which is a host:port pair.

• host is by default lowercased resource name
• port number is 3000 by default(can be changed by specifying port)

Following example shows privateApi service. host:port pair in this case will be privateapi:3000.

• You can connect to this address directly from other resources of your stack.

• You may need to append a URL scheme to the private service address depending on your app requirements. For example, apps that rely on HTTP api endpoint of sorts might require you to specify it, i.e http://privateapi:3000

YAML
TypeScript
Copy
resources:
  publicService:
    type: web-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/main.ts
      resources:
        cpu: 1
        memory: 1024
      environment:
        # injecting privateApi address
        - name: PRIVATE_ADDRESS
          value: $ResourceParam('privateApi', 'address')

  privateApi:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/private-api/main.ts
      resources:
        cpu: 1
        memory: 1024

Image

• Private service is a running instance of a Docker image.
• The image of the container can be supplied in 4 different ways:
  • images built using stacktape-image-buildpack
  • images built using external-buildpack
  • images built from the custom-dockerfile
  • prebuilt-images

Environment variables

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/main.ts
      environment:
        - name: STATIC_ENV_VAR
          value: my-env-var
        - name: DYNAMICALLY_SET_ENV_VAR
          value: $MyCustomDirective('input-for-my-directive')
        - name: DB_HOST
          value: $ResourceParam('myDatabase', 'host')
        - name: DB_PASSWORD
          value: $Secret('dbSecret.password')
      resources:
        cpu: 2
        memory: 2048

Healthcheck

The purpose of the container health check is to monitor the health of the container from the inside.

Once an essential container of an instance is determined UNHEALTHY, the instance is automatically replaced with a new one.

• Example: A shell command sends a curl request every 20 seconds to determine if the service is available. If the request fails (or doesn't return in 5 seconds), the command returns with non-zero exit code, and the healthcheck is considered failed.

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/index.ts
      internalHealthCheck:
        healthCheckCommand: ['CMD-SHELL', 'curl -f http://localhost/ || exit 1']
        intervalSeconds: 20
        timeoutSeconds: 5
        startPeriodSeconds: 150
        retries: 2
      resources:
        cpu: 2
        memory: 2048

Shutdown

• When a running private service instance is deregistered (removed), all running containers receive a SIGTERM signal.
• You then have 30 seconds to clean up. After 30 seconds, your process receives a SIGKILL signal.

Copy
process.on('SIGTERM', () => {
  console.info('Received SIGTERM signal. Cleaning up and exiting process...');

  // Finish any outstanding requests, or close a database connection...

  process.exit(0);
});

Logging

• Every time your code outputs (prints) something to the stdout or stderr, your log will be captured and stored in a AWS CloudWatch log group.
• You can browse your logs in 2 ways:
  • go to your private service's log-group in the AWS CloudWatch console. You can use stacktape stack-info command to get a direct link.
  • use stacktape logs command that will print logs to the console

Resources

In resources section, you specify amounts of cpu/memory and EC2 instance types available to your service.

There are two ways to run your containers:

1. using Fargate

   • Fargate is a serverless, pay-as-you-go compute engine for running containers without having to manage underlying instances (servers).
   • With Fargate you only need to specify cpu and memory required for your service.
   • While slightly more expensive, using Fargate is often preferred in strictly regulated industries since running containers on Fargate meets the standards for PCI DSS Level 1, ISO 9001, ISO 27001, ISO 27017, ISO 27018, SOC 1, SOC 2, SOC 3 out of the box.

2. using EC2 instances

   • EC2 instances are virtual machines (VMs) ran on AWS cloud.
   • Containers are placed on the EC2 instances which are added and removed depending on service needs.
   • You can choose instance type that suit your resource requirements the best.

Following applies when configuring resources section of your service:

Using Fargate

If you do not specify instanceTypes property in resources section, Fargate is used to run your containers.

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/index.ts
      resources:
        cpu: 0.25
        memory: 512

Using EC2 instances

If you specify instanceTypes property in resources section, EC2 instances are used to run your containers.

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/index.ts
      resources:
        instanceTypes:
          - c5.large

Placing containers on EC2

Stacktape aims to achieve 100% utilization of your EC2 instances. However this is not always possible and following behavior can be expected:

• If you only specify one type in instanceTypes and you do NOT set memory and cpu then Stacktape sets memory and cpu to fit the EC2 instance type precisely(see also Default cpu and memory section).

  This means that if your service scales(new instance of service is added), new EC2 instance is added as well.

• If you specify cpu and memory properties alongside instanceTypes, they will be respected. If the EC2 instance is larger (has more resources) than specified cpu and memory, AWS places instances of your service on available EC2 instances using binpack strategy. This strategy aims to put as many instances of your service on the available EC2 instances as possible(to maximize utilization).

Scaling

In scaling section, you can configure scaling behavior of your service. You can configure:

• Minimum and maximum amount of concurrently running instances of your service.
• Conditions which trigger the scaling (up or down) using a scaling policy.

Scaling policy

• A scaling policy specifies CPU and memory metric thresholds which trigger the scaling process.

• Depending on the thresholds, the compute resource can either scale out (add instances) or scale in (remove instances).

• If both keepAvgCpuUtilizationUnder and keepAvgMemoryUtilizationUnder are used, the compute resource will scale-out if one of the metrics is above the target value. However, to scale in, both of these metrics need to be below their respective target values.

• Scaling policy is more aggressive in adding capacity then removing capacity. For example, if the policy's specified metric reaches its target value, the policy assumes that your application is already heavily loaded. So it responds by adding capacity proportional to the metric value as fast as it can. The higher the metric, the more capacity is added.

• When the metric falls below the target value, the policy expects that utilization will eventually increase again. Therefore it slows down the scale-in process by removing capacity only when utilization passes a threshold that is far enough below the target value (usually 20% lower).

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/index.ts
      resources:
        cpu: 0.5
        memory: 1024
      scaling:
        minInstances: 1
        maxInstances: 5
        scalingPolicy:
          keepAvgMemoryUtilizationUnder: 80
          keepAvgCpuUtilizationUnder: 80

Storage

• Each private service instance has access to its own ephemeral storage. It's removed after the private service instances is removed.
• It has a fixed size of 20GB.
• If you have 2 concurrently running private service instances, they do not share this storage.
• To store data persistently, consider using Buckets.

Accessing other resources

• For most of the AWS resources, resource-to-resource communication is not allowed by default. This helps to enforce security and resource isolation. Access must be explicitly granted using IAM (Identity and Access Management) permissions.

• Access control of Relational Databases is not managed by IAM. These resources are not "cloud-native" by design and have their own access control mechanism (connection string with username and password). They are accessible by default, and you don't need to grant any extra IAM permissions. You can further restrict the access to your relational databases by configuring their access control mode.

• Stacktape automatically handles IAM permissions for the underlying AWS services that it creates (i.e. granting web services permission to write logs to Cloudwatch, allowing private services to communicate with their event source and many others).

If your compute resource needs to communicate with other infrastructure components, you need to add permissions manually. You can do this in 2 ways:

Using connectTo

• List of resource names or AWS services that this service will be able to access (basic IAM permissions will be granted automatically). Granted permissions differ based on the resource.
• Works only for resources managed by Stacktape in resources section (not arbitrary Cloudformation resources)
• This is useful if you don't want to deal with IAM permissions yourself. Handling permissions using raw IAM role statements can be cumbersome, time-consuming and error-prone. Moreover, when using connectTo property, Stacktape automatically injects information about resource you are connecting to as environment variables into your workload.

YAML
TypeScript
Copy
resources:
  photosBucket:
    type: bucket

  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/index.ts
      connectTo:
        # access to the bucket
        - photosBucket
        # access to AWS SES
        - aws:ses
      resources:
        cpu: 0.25
        memory: 512

Using iamRoleStatements

• List of raw IAM role statement objects. These will be appended to the private service's role.
• Allow you to set granular control over your private service's permissions.
• Can be used to give access to any Cloudformation resource

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: server/index.ts
      iamRoleStatements:
        - Resource:
            - $CfResourceParam('NotificationTopic', 'Arn')
          Effect: 'Allow'
          Action:
            - 'sns:Publish'
      resources:
        cpu: 2
        memory: 2048

cloudformationResources:
  NotificationTopic:
    Type: 'AWS::SNS::Topic'

Load balancing

LoadBalancing property is used to configure what type of entry point is used for distributing traffic to containers:

YAML
TypeScript
Copy
resources:
  webService:
    type: web-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/main.ts
      resources:
        cpu: 2
        memory: 2048
      loadBalancing:
        type: application-load-balancer # default is http-api-gateway

Default VPC connection

• Certain AWS services (such as Relational Databases) must be connected to a VPC (Virtual private cloud) to be able to run. For stacks that include these resources, Stacktape does 2 things:
  • creates a default VPC
  • connects the VPC-requiring resources to the default VPC.
• private services are connected to the default VPC of your stack by default. This means that private services can communicate with resources that have their accessibility mode set to vpc without any extra configuration.
• To learn more about VPCs and accessibility modes, refer to VPC docs, accessing relational databases, accessing redis clusters and accessing MongoDb Atlas clusters.

Port

Optionally you can specify your own preferred alias or port

YAML
TypeScript
Copy
resources:
  myPrivateService:
    type: private-service
    properties:
      packaging:
        type: stacktape-image-buildpack
        properties:
          entryfilePath: src/main.ts
      resources:
        cpu: 2
        memory: 2048
      port: 8080

Referenceable parameters

Pricing

You are charged for:

• Virtual CPU / hour:

  • depending on the region $0.04048 - $0.0696

• Memory GB / hour:

  • depending on the region $0.004445 - $0.0076

The duration is rounded to 1 second with a 1 minute minimum. To learn more, refer to AWS Fargate pricing.

API reference