Porter

https://docs.porter.run
Admin
Porter is a PaaS that runs in your own cloud, simplifying application deployment and infrastructure...
Tokens:62,328
Snippets:691
Trust Score:8.9
Update:8 months ago
Show doc for...
Tokens:
Raw
### Example: Install NGINX Ingress via Helm CLI

Source: https://docs.porter.run/addons/custom-helm-charts

An example demonstrating how to add the ingress-nginx Helm repository, update it, and then install the ingress-nginx chart. This showcases a practical application of deploying a common ingress controller using Porter's Helm integration.

```bash
# Add the ingress-nginx repository
porter helm -- repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
porter helm -- repo update

# Install the chart
porter helm -- install my-ingress ingress-nginx/ingress-nginx \
  --namespace ingress \
  --create-namespace
```

--------------------------------

### Configure Pre-deployment Job for Database Migrations

Source: https://docs.porter.run/applications/deploy/configuring-application-services

Set up pre-deployment jobs (migration jobs) to run essential setup tasks, such as database migrations, before the main application starts and traffic is routed. Configure a start command for your migration script and allocate appropriate resources and timeouts. The job must complete successfully for the deployment to proceed.

```yaml
preDeploymentJobs:
  - name: "database-migrations"
    command: "npm run migrate"
    resources:
      cpu: 500m
      memory: 1Gi
    timeout: "5m"
```

--------------------------------

### Example Comprehensive Porter.yaml Configuration

Source: https://docs.porter.run/applications/configuration-as-code/overview

An extensive `porter.yaml` example demonstrating various configurations for web, worker, and job services, including autoscaling, health checks, environment variables, and build settings. This serves as a reference for advanced setups.

```yaml
version: v2
name: my-app

services:
  - name: api
    type: web
    run: node index.js
    port: 8080
    cpuCores: 0.1
    ramMegabytes: 256
    autoscaling:
      enabled: true
      minInstances: 1
      maxInstances: 3
      memoryThresholdPercent: 60
      cpuThresholdPercent: 60
    private: false
    domains:
      - name: test1.example.com
    healthCheck:
      enabled: true
      httpPath: /healthz
  - name: example-wkr
    type: worker
    run: echo 'work'
    port: 8081
    cpuCores: 0.1
    ramMegabytes: 256
    instances: 1
  - name: example-job
    type: job
    run: echo 'hello world'
    allowConcurrent: true
    cpuCores: 0.1
    ramMegabytes: 256
    cron: '*/10 * * * *'

predeploy:
  run: ls

build:
	method: docker
	context: "./"
	dockerfile: "./app/Dockerfile"

env:
  NODE_ENV: production

envGroups:
- production-env-group
```

--------------------------------

### Connect to Datastore Examples

Source: https://docs.porter.run/standard/cli/command-reference/porter-datastore-connect

Examples demonstrating how to use the 'porter datastore connect' command to establish a connection to a datastore named 'my-postgres', including an example with a custom port.

```bash
porter datastore connect my-postgres
```

```bash
porter datastore connect my-postgres --port 5433
```

--------------------------------

### Porter Configuration File Example (YAML)

Source: https://docs.porter.run/standard/cli/command-reference/porter-apply

A minimal example of a 'porter.yaml' configuration file. This file defines the application version, name, and its services, including run commands, ports, and resource allocations.

```yaml
version: v2
name: my-app

services:
  - name: web
    type: web
    run: npm start
    port: 3000
    cpuCores: 0.5
    ramMegabytes: 512
```

--------------------------------

### Install Porter CLI using Homebrew or Script

Source: https://docs.porter.run/getting-started/quickstart

Instructions for installing the Porter CLI on macOS using Homebrew or on macOS/Linux using an installation script. This is a prerequisite for using the Porter CLI for deployments.

```bash
# Mac (Homebrew)
brew install porter-dev/porter/porter

# Mac/Linux (script)
/bin/bash -c "$(curl -fsSL https://install.porter.run)"
```

--------------------------------

### Start Temporal Workflow - Python

Source: https://docs.porter.run/applications/configure/temporal-autoscaling

This Python snippet demonstrates how to start a Temporal workflow using the `temporalio.client.Client`. It's typically used in a web service to initiate background processing for uploaded documents. It requires the `temporalio` library and an initialized `temporal_client`.

```python
from temporalio.client import Client

@app.post("/upload")
async def upload_document(file: UploadFile):
    # Start a Temporal workflow for each uploaded document
    await temporal_client.start_workflow(
        ProcessDocumentWorkflow.run,
        args=[file.filename],
        id=f"doc-{uuid4()}",
        task_queue="document-processing"
    )
    return {"status": "processing"}
```

--------------------------------

### Porter Apply Command Examples (Bash)

Source: https://docs.porter.run/standard/cli/command-reference/porter-apply

Demonstrates various ways to use the 'porter apply' command for different deployment scenarios. These examples cover basic deployment, waiting for completion, previewing environments, validating syntax, performing dry runs, CI/CD pipeline usage, skipping builds, and deploying with runtime variables and secrets.

```bash
# Deploy using porter.yaml in the current directory
porter apply -f porter.yaml
```

```bash
# Deploy and wait for the deployment to complete
porter apply -f porter.yaml --wait
```

```bash
# Deploy to a preview environment
porter apply -f porter.yaml --preview
```

```bash
# Check that porter.yaml is valid YAML
porter apply -f porter.yaml --validate
```

```bash
# Validate the full configuration server-side without deploying
porter apply -f porter.yaml --dry-run
```

```bash
# Deploy in a CI/CD pipeline with explicit configuration
PORTER_TOKEN=$PORTER_DEPLOY_TOKEN \
PORTER_PROJECT=$PROJECT_ID \
PORTER_CLUSTER=$CLUSTER_ID \
porter apply -f porter.yaml
```

```bash
# Deploy using an existing image (skip build step)
porter apply -f porter.yaml --no-build --tag v1.2.3
```

```bash
# Deploy with runtime environment variables and secrets
porter apply -f porter.yaml --variables LOG_LEVEL=debug,NODE_ENV=production --secrets API_KEY=secret123
```

--------------------------------

### Basic Service Configuration Example

Source: https://docs.porter.run/applications/configuration-as-code/reference

A fundamental example demonstrating the structure for defining web services, including essential fields like name, type, run command, resource allocation (CPU, RAM), and instance count. It also shows how to specify a custom node group for a service.

```yaml
services:
  - name: web
    type: web
    run: python app.py
    instances: 1
    cpuCores: 1
    ramMegabytes: 1024
    port: 8080
  - name: web-on-user-node-group
    type: web
    run: python app.py
    instances: 1
    cpuCores: 1
    ramMegabytes: 1024
    port: 8080
    nodeGroup: 123e4567-e89b-12d3-a456-426614174000
```

--------------------------------

### Automated Azure Service Principal Setup Script

Source: https://docs.porter.run/cloud-accounts/connecting-a-cloud-account

This bash script automates the creation of an Azure service principal for Porter. It requires the Azure CLI to be installed and authenticated. The script enables resource providers, creates a custom role, sets up the service principal with permissions, adds Microsoft Graph API permissions, and grants admin consent.

```bash
# Download the setup script
curl -O https://raw.githubusercontent.com/porter-dev/docs/main/scripts/setup-azure-porter.sh

# Make it executable
chmod +x setup-azure-porter.sh

# Run the script (optionally provide subscription ID)
./setup-azure-porter.sh [your-subscription-id]
```

--------------------------------

### Complete Application Configuration Example - YAML

Source: https://docs.porter.run/applications/configuration-as-code/services/worker-service

A comprehensive example demonstrating the configuration of a worker service, including autoscaling, health checks, cloud connections, service mesh enablement, and graceful termination.

```yaml
services:
  - name: queue-processor
    type: worker
    run: npm run worker
    cpuCores: 1
    ramMegabytes: 2048

    # Autoscaling
    autoscaling:
      enabled: true
      minInstances: 2
      maxInstances: 20
      cpuThresholdPercent: 70
      memoryThresholdPercent: 80

    # Health checks
    livenessCheck:
      enabled: true
      command: ./healthcheck.sh
      timeoutSeconds: 5
    readinessCheck:
      enabled: true
      command: ./ready.sh
      timeoutSeconds: 3

    # Cloud connections
    connections:
      - type: awsRole
        role: worker-sqs-access

    # Service mesh
    serviceMeshEnabled: true

    # Graceful shutdown (allow 2 minutes for jobs to complete)
    terminationGracePeriodSeconds: 120
```

--------------------------------

### Connecting to Datastores via Tunnel

Source: https://docs.porter.run/standard/cli/command-reference/porter-datastore-connect

These examples show how to connect to specific datastore types (PostgreSQL and Redis) using a client after a secure tunnel has been established by the 'porter datastore connect' command. It highlights the use of the local port specified during the tunnel setup.

```bash
psql -h 127.0.0.1 -p 8122 -U postgres -d postgres
```

```bash
redis-cli -p 8122 -a [YOUR_DATASTORE_PASSWORD] --tls
```

--------------------------------

### Complete Service Configuration Example

Source: https://docs.porter.run/applications/configuration-as-code/services/web-service

A comprehensive example demonstrating the configuration of a service, including autoscaling, custom domains, health checks, path routing, ingress annotations, service mesh, metrics scraping, cloud connections, and graceful shutdown.

```yaml
services:
  - name: api
    type: web
    run: npm start
    port: 8080
    cpuCores: 1
    ramMegabytes: 1024

    # Autoscaling
    autoscaling:
      enabled: true
      minInstances: 1
      maxInstances: 10
      cpuThresholdPercent: 80
      memoryThresholdPercent: 80

    # Custom domains
    domains:
      - name: example.com

    # Health checks
    livenessCheck:
      enabled: true
      httpPath: /livez
      timeoutSeconds: 1
      initialDelaySeconds: 15
    readinessCheck:
      enabled: true
      httpPath: /readyz
      timeoutSeconds: 1
      initialDelaySeconds: 15

    # Path routing
    pathRouting:
      - path: /api/v1/
        port: 8080
      - path: /api/v2/
        port: 8081
    pathRoutingConfig:
      rewriteMode: rewrite-prefix

    # Ingress configuration
    ingressAnnotations:
      nginx.ingress.kubernetes.io/proxy-connect-timeout: "18000"

    # Service mesh and metrics
    serviceMeshEnabled: true
    metricsScraping:
      enabled: true
      path: /metrics
      port: 9090
      scrapeIntervalSeconds: 60

    # Cloud connections
    connections:
      - type: awsRole
        role: api-s3-access

    # Graceful shutdown
    terminationGracePeriodSeconds: 30
```

--------------------------------

### Porter Application Configuration (`porter.yaml`)

Source: https://docs.porter.run/getting-started/quickstart

Example `porter.yaml` file for defining an application's configuration. This file specifies the application name, build method, and service details including port, CPU, and RAM. It's used by the `porter apply` command.

```yaml
version: v2
name: my-app

build:
  method: docker
  dockerfile: ./Dockerfile

services:
  - name: web
    type: web
    run: npm start
    port: 3000
    cpuCores: 0.5
    ramMegabytes: 512
```

--------------------------------

### Complete Application Configuration Example (YAML)

Source: https://docs.porter.run/applications/configuration-as-code/reference

A comprehensive example of an application configuration file in YAML format. It demonstrates various service types (web, worker, job), build settings, environment variables, autoscaling, health checks, and includes the metrics scraping configuration for a web service.

```yaml
version: v2
name: my-app

build:
  method: docker
  context: .
  dockerfile: ./Dockerfile

env:
  PORT: "8080"
  LOG_LEVEL: "info"

envGroups:
  - production-secrets
  - shared-config

predeploy:
  run: python manage.py migrate
  cpuCores: 0.5
  ramMegabytes: 512

initialDeploy:
  run: python manage.py seed
  cpuCores: 0.25
  ramMegabytes: 256

autoRollback:
  enabled: true

efsStorage:
  enabled: true

services:
  # Web service with all options
  - name: web
    type: web
    run: python app.py
    instances: 2
    cpuCores: 1
    ramMegabytes: 1024
    port: 8080
    terminationGracePeriodSeconds: 30
    autoscaling:
      enabled: true
      minInstances: 2
      maxInstances: 10
      cpuThresholdPercent: 80
      memoryThresholdPercent: 80
    healthCheck:
      enabled: true
      httpPath: /healthz
    domains:
      - name: app.example.com
    metricsScraping:
      enabled: true
      path: /metrics
      port: 9090
      scrapeIntervalSeconds: 30
    connections:
      - type: awsRole
        role: my-app-role

  # GPU-enabled worker on a custom node group
  - name: ml-worker
    type: worker
    run: python ml_worker.py
    instances: 1
    cpuCores: 4
    ramMegabytes: 16384
    gpuCoresNvidia: 1
    nodeGroup: 123e4567-e89b-12d3-a456-426614174000
    terminationGracePeriodSeconds: 60
    serviceMeshEnabled: true

  # Background worker
  - name: worker
    type: worker
    run: python worker.py
    instances: 1
    cpuCores: 0.5
    ramMegabytes: 512

  # Scheduled job
  - name: cleanup
    type: job
    run: python cleanup.py
    cpuCores: 0.5
    ramMegabytes: 256
    cron: "0 0 * * *"
```

--------------------------------

### Check Container PATH and Start Command

Source: https://docs.porter.run/applications/debug/common-errors

This snippet demonstrates how to check the executable commands available in the container's PATH and verify the start command. It's useful for debugging issues related to the application's entry point.

```bash
which <start-command>
echo $PATH
```

--------------------------------

### Install Helm Chart with Version and Values from Files

Source: https://docs.porter.run/addons/custom-helm-charts

Demonstrates installing a Helm chart using values and version information extracted from YAML files. This approach is beneficial for managing complex configurations and integrating with CI/CD pipelines where configuration is stored in version control.

```bash
CHART_URL=$(yq e '.chartUrl' porter-custom-helm-chart-addons/custom-chart/chart.yaml)
VERSION=$(yq e '.version' porter-custom-helm-chart-addons/custom-chart/chart.yaml)

porter helm -- install custom-chart $CHART_URL \
  --version $VERSION \
  --values porter-custom-helm-chart-addons/custom-chart/values.yaml
```

--------------------------------

### List Porter Applications

Source: https://docs.porter.run/standard/cli/command-reference/porter-app

Lists all applications currently configured within the Porter project. This command provides a simple overview of deployed applications. It requires the Porter CLI to be installed and configured for the project.

```bash
porter app list
```

--------------------------------

### Persistent Disk Connection Example

Source: https://docs.porter.run/applications/configuration-as-code/services/connections

This example illustrates how to attach a persistent disk to a service for durable storage. It requires specifying the connection type as 'disk' and providing the name of the persistent disk.

```yaml
services:
  - name: api
    # ...
    connections:
      - type: disk
        config:
          diskName: my-persistent-data
```

--------------------------------

### Configure Initial Deploy Job in Porter.yaml

Source: https://docs.porter.run/applications/configuration-as-code/reference

Set up an initial deploy job that runs only during the first deployment of a preview environment. This is useful for one-time setup tasks such as database seeding. It requires a 'run' command and can specify CPU and memory limits.

```yaml
initialDeploy:
  run: npm run seed
  cpuCores: 0.25
  ramMegabytes: 256
```

--------------------------------

### Get Azure Egress IPs using Azure CLI

Source: https://docs.porter.run/security-and-compliance/static-egress-ip

Fetches the egress IP address for your Porter cluster in Azure using the Azure CLI. This involves two steps: first getting the public IP ID, then retrieving the IP address itself. Requires Azure CLI installation and configuration. Outputs a single egress IP.

```bash
az aks show -g <resource-name> -n <cluster-name> --query 'networkProfile.loadBalancerProfile.effectiveOutboundIPs[].id'
```

```bash
az network public-ip show --ids <id> --query ipAddress -o tsv
```

--------------------------------

### Pin Helm Chart Version for Reproducibility

Source: https://docs.porter.run/addons/custom-helm-charts

Example of how to specify a chart version during installation to ensure reproducible deployments. Version pinning is a best practice for managing dependencies and preventing unexpected changes due to automatic updates.

```bash
porter helm -- install my-release repo/chart --version 1.2.3
```

--------------------------------

### Get AWS Egress IPs using AWS CLI

Source: https://docs.porter.run/security-and-compliance/static-egress-ip

Retrieves the public IP addresses of NAT gateways associated with your Porter cluster in AWS. Requires AWS CLI installation and configuration. Outputs a list of egress IPs.

```bash
aws --region <REGION> ec2 describe-nat-gateways --filter "Name=tag-key,Values=*/cluster/<CLUSTER_NAME>" --query "NatGateways[*].NatGatewayAddresses[0].PublicIp"
```

--------------------------------

### Get GCP Egress IPs using gcloud CLI

Source: https://docs.porter.run/security-and-compliance/static-egress-ip

Lists the static egress IP addresses for your Porter cluster in GCP using the gcloud CLI. Requires gcloud CLI installation and configuration. Outputs a list of egress IPs.

```bash
gcloud compute addresses list --filter="region:REGION AND users~.*routers/.*-cloud-router$"
```

--------------------------------

### GitHub Actions Workflow for Porter Deployment (YAML)

Source: https://docs.porter.run/standard/cli/command-reference/porter-apply

An example GitHub Actions workflow file that demonstrates how to set up and run the 'porter apply' command within a CI/CD pipeline. It includes steps for checking out code, setting up Porter, and deploying the application using environment variables for configuration.

```yaml
name: Deploy to my-app

on:
  push:
    branches:
      - main

jobs:
  porter-deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set Github tag
        id: vars
        run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT

      - name: Setup porter
        uses: porter-dev/setup-porter@v0.1.0

      - name: Deploy stack
        run: porter apply
        timeout-minutes: 30
        env:
          PORTER_CLUSTER: "1"
          PORTER_HOST: https://dashboard.porter.run
          PORTER_PROJECT: "1"
          PORTER_TOKEN: ${{ secrets.PORTER_TOKEN }}
          PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
          PORTER_APP_NAME: my-app
          PORTER_DEPLOYMENT_TARGET_ID: your-deployment-target-id
```

--------------------------------

### Verify Porter CLI Installation

Source: https://docs.porter.run/cli/installation

Checks the installed version of the Porter CLI to confirm a successful installation. This command should be run after completing the installation steps.

```bash
porter version
```

--------------------------------

### Create a Porter App

Source: https://docs.porter.run/standard/cli/command-reference/porter-app

Creates and deploys a new app in your project. If no flags are specified, you will be directed to a series of required prompts to configure the app. This command supports interactive creation, specifying an app name, or creating from a YAML file.

```bash
porter app create
```

```bash
porter app create --name example-app
```

```bash
porter app create --name my-app -f porter.yaml
```

--------------------------------

### Install Porter CLI Manually (macOS, Linux)

Source: https://docs.porter.run/cli/installation

Installs the Porter CLI on macOS and Linux using a curl command to download and execute the installation script. This method requires `curl` and `unzip` utilities to be present on the system.

```bash
/bin/bash -c "$(curl -fsSL https://install.porter.run)"
```

--------------------------------

### CI/CD Integration: GitHub Actions for Porter App Updates

Source: https://docs.porter.run/applications/deploy/deploy-from-docker-registry

This example demonstrates how to integrate Porter application updates into a GitHub Actions workflow. It includes steps for building and pushing a Docker image, then using the Porter CLI to deploy the new tag. It requires a PORTER_TOKEN secret for authentication.

```yaml
- name: Build and push image
  run: |
    docker build -t myregistry.com/myapp:${{ github.sha }} .
    docker push myregistry.com/myapp:${{ github.sha }}

- name: Deploy to Porter
  run: porter app update-tag myapp --tag ${{ github.sha }}
  env:
    PORTER_TOKEN: ${{ secrets.PORTER_TOKEN }}
```

--------------------------------

### Install Porter CLI via Homebrew (macOS)

Source: https://docs.porter.run/cli/installation

Installs the Porter CLI on macOS using the Homebrew package manager. This is a straightforward command to add the Porter CLI to your system.

```bash
brew install porter-dev/porter/porter
```

--------------------------------

### Multiple Connections Example

Source: https://docs.porter.run/applications/configuration-as-code/services/connections

This example shows how to attach multiple connections, including an AWS role and a persistent disk, to a single service. Note that only one of each connection type can be attached per service.

```yaml
services:
  - name: api
    # ...
    connections:
      - type: awsRole
        role: api-s3-access
      - type: disk
        config:
          diskName: cache-storage
```

--------------------------------

### AWS Role Connection Example

Source: https://docs.porter.run/applications/configuration-as-code/services/connections

This example demonstrates how to attach an IAM role to a service for AWS API access. It requires specifying the connection type as 'awsRole' and providing the IAM role name.

```yaml
services:
  - name: api
    # ...
    connections:
      - type: awsRole
        role: my-app-s3-access
```

--------------------------------

### CI/CD Deployment with Porter CLI

Source: https://docs.porter.run/cli/basic-usage

Shows how to perform a CI/CD deployment using the Porter CLI, emphasizing the use of environment variables for token, project, and cluster configuration before applying the `porter.yaml` file.

```bash
# Deploy with explicit configuration
PORTER_TOKEN=$DEPLOY_TOKEN \
PORTER_PROJECT=$PROJECT_ID \
PORTER_CLUSTER=$CLUSTER_ID \
porter apply -f porter.yaml
```

--------------------------------

### Example porter.yaml for Multiple Apps and Addons

Source: https://docs.porter.run/applications/configuration-as-code/addons-porter-yaml

This YAML configuration demonstrates how to define multiple applications (backend, frontend, api) and addons (cache, db) within a single `porter.yaml` file. It specifies service configurations, environment group mappings, and addon details.

```yaml
apps:
  - version: v2
    name: backend
    services:
      - name: server
        run: ""
        type: web
        instances: 1
        cpuCores: 0.2
        ramMegabytes: 100
        terminationGracePeriodSeconds: 30
        port: 80
        sleep: false
        private: true
    envGroups: # Environment groups can be used to inject environment variables from the addons into the service.
      - cache
      - db
    image:
      repository: nginx
      tag: latest
  - version: v2
    name: frontend
    services:
      - name: dashboard
        run: ""
        type: web
        instances: 1
        cpuCores: 0.2
        ramMegabytes: 100
        terminationGracePeriodSeconds: 30
        port: 80
        sleep: false
        private: true
    envGroups:
      - cache
      - db
    image:
      repository: nginx
      tag: latest
  - version: v2
    name: api
    services:
      - name: worker
        run: ""
        type: worker
        instances: 1
        cpuCores: 0.2
        ramMegabytes: 100
        terminationGracePeriodSeconds: 30
        port: 80
        sleep: false
    envGroups:
      - cache
      - db
    image:
      repository: nginx
      tag: latest
addons:
  - name: cache
    type: MANAGED-REDIS
    engine: REDIS
    values:
      config:
        name: cache
        masterUserPassword: password
        allocatedStorage: 2 # Persistent storage size in GB. Cannot be changed after creation.
        cpuCores: 0.1
        ramMegabytes: 110
  - name: db
    type: MANAGED-POSTGRES
    engine: POSTGRES
    values:
      config:
        name: db
        masterUserPassword: password
        allocatedStorage: 2
        cpuCores: 0.1
        ramMegabytes: 110
```

--------------------------------

### Prometheus Metrics Exposition Format Example

Source: https://docs.porter.run/applications/observability/custom-metrics-and-autoscaling

An example of how metrics should be exposed in Prometheus format. This format is crucial for Porter to scrape and interpret your application's performance data for autoscaling purposes.

```prometheus
# HELP http_requests_total Total number of HTTP requests
# TYPE http_requests_total counter
http_requests_total{method="post",code="200"} 1027
http_requests_total{method="get",code="200"} 2048
```

--------------------------------

### Deploy Preview Environment with Porter CLI

Source: https://docs.porter.run/applications/configuration-as-code/overview

The `porter apply` command with the `--preview` flag allows you to spin up isolated preview environments for pull requests, ensuring consistent configuration for testing.

```bash
porter apply -f porter.yaml --preview
```

--------------------------------

### Build Application Image

Source: https://docs.porter.run/standard/cli/command-reference/porter-app

Builds a new version of a specified application. It can utilize existing build settings or be configured with custom build contexts, Dockerfiles, tags, and build methods (docker or pack).

```bash
porter app build my-app

```

```bash
porter app build my-app --build-context ./frontend --dockerfile ./frontend/Dockerfile

```

```bash
porter app build my-app --tag v1.2.3

```

```bash
porter app build my-app --build-method pack --builder heroku/builder:22 --attach-buildpacks heroku/nodejs

```

--------------------------------

### Cloud SQL Connection Example (GCP)

Source: https://docs.porter.run/applications/configuration-as-code/services/connections

This example shows how to connect to Google Cloud SQL instances using the Cloud SQL Auth Proxy. It requires the connection type, Cloud SQL instance connection name, database port, and GCP service account.

```yaml
services:
  - name: api
    # ...
    connections:
      - type: cloudSql
        config:
          cloudSqlConnectionName: my-project-123456:us-east1:my-instance
          cloudSqlDatabasePort: 5432
          cloudSqlServiceAccount: my-service-account
```

--------------------------------

### Manual Azure Service Principal Creation with Azure CLI

Source: https://docs.porter.run/cloud-accounts/connecting-a-cloud-account

This section outlines the manual steps to create an Azure service principal for Porter using the Azure CLI. It includes enabling necessary resource providers, defining and creating a custom role for Porter, and then creating the service principal with the defined role and scope. The output provides credentials required by Porter.

```bash
# Set your subscription ID
PORTER_AZURE_SUBSCRIPTION_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

# Create the role
envsubst << EOF | az role definition create --role-definition @-
{
    "assignableScopes": ["/subscriptions/${PORTER_AZURE_SUBSCRIPTION_ID}"],
    "description": "Grants Porter access to manage resources for an AKS cluster.",
    "id": "/subscriptions/${PORTER_AZURE_SUBSCRIPTION_ID}/providers/Microsoft.Authorization/roleDefinitions/porter-aks-restricted",
    "isCustom": true,
    "name": "porter-aks-restricted",
    "permissions": [
        {
            "actions": ["*"],
            "dataActions": [],
            "notActions": [
                "Microsoft.Authorization/elevateAccess/Action",
                "Microsoft.Blueprint/blueprintAssignments/write",
                "Microsoft.Blueprint/blueprintAssignments/delete",
                "Microsoft.Compute/galleries/share/action"
            ],
            "notDataActions": []
        }
    ],
    "roleName": "Contributor",
    "roleType": "BuiltInRole",
    "type": "Microsoft.Authorization/roleDefinitions"
}
EOF

az ad sp create-for-rbac \
  --name="azure-porter-restricted-sp" \
  --role="porter-aks-restricted" \
  --scopes="/subscriptions/${PORTER_AZURE_SUBSCRIPTION_ID}"
```

```json
{
  "appId": "00000000-0000-0000-0000-000000000000",
  "displayName": "azure-porter-restricted-sp",
  "password": "0000-0000-0000-0000-000000000000",
  "tenant": "00000000-0000-0000-0000-000000000000"
}
```
Tokens:
Raw