"We're noticing issues with dyno restarts, dyno scaling, release phase, builds, app setups and Heroku CI"

so, all the things, then. https://t.co/NPqOszQM1u

— Jon Yongfook (@yongfook) April 26, 2022

I'm pretty salty Heroku hasn't communicated when they're planning on fixing or making their GitHub integration work again.

I totally understand the desire to not give a firm date, but come on, it's been like 11 days and we're still unable to use review apps among other features.

— Andrea Fomera (@afomera) April 26, 2022

If you're an Indian company, don't bother trying to pay for your Heroku account right now. Because Heroku is just flat out refusing to accept any India-issued cards. We even asked them for one-time payment links, but no luck. Thank you RBI for protecting us 🙏🏾 pic.twitter.com/ffQxscVcWA

— Rohin Dharmakumar (@r0h1n) April 14, 2022

Owning a credit card in India is almost pointless for subscriptions/online services!@heroku is there anyway I can pay for your service?https://t.co/ljvf1sC7jP

— Mustafa (@mufasaYC) March 13, 2022

This is not an acceptable. I’m an Indian and I stay in India, from where can I get a non Indian card?⁰When I started using @heroku you used to accept Indian cards, now you can’t accept, that’s your problem, why’re you suspending my account? Why should I suffer?@SalesforceOrg pic.twitter.com/UwCzxr2nGo

— Rivu Chakraborty (@rivuchakraborty) February 24, 2022

I'm sad to say but I think we're witnessing the demise of Heroku:

· Stagnated product offering
· Customer-hostile practices (e.g. no easy way to access Performance dynos)
· Recent security incident with GitHub tokens (including poor/lack of communication)
· Reliability issues

— Greg Navis (@gregnavis) April 27, 2022

Depending on who you ask, Heroku has been in steady decline - or at the very least, has stagnated at the technological level - since its acquisition by Salesforce in 2010.

— Hacker News (@Hacker__News) April 27, 2022

I feel like they exploded on the scene, got acquired by Salesforce, and then stagnated as the Enterprise sales team moved in. Heroku ops are still first-class (until last week at least 😅), but there’s been no product or pricing innovation in years. Only two regions, in 2022??

— Dave (@davemetrics) April 27, 2022

` tag with a blue background and white foreground. A slightly more advanced example could include a conditional style: ```jsx import styled from 'styled-components' const Text = styled.p( ({ inverse }) => ` background-color: ${inverse ? 'white' : 'blue'}; color: ${inverse ? 'blue' : 'white'}; ` ) Hello world! ``` Here, the background and foreground colours will switch depending on whether or not the component is passed the `inverse` prop. ### How to add UI themes using React and styled-components To make styling inside an application easier, we will want to have some rules and variables that can apply to all components. For example, if you have a specific brand colour in your application, you don’t really want to be defining the hex value every time you need to use it within a component. What happens if the brand colour changes? Ideally we can define the value once and then reuse the same variable wherever needed. To achieve this, we can put together some simple objects that will contain our theme. `src/app/themes.js` ```javascript export const base = { ​​breakpoints: ['768px'], space: ['0px', '2px', '4px', '8px', '16px', '32px', '64px', ...], fonts: { heading: 'Inter, system-ui, sans-serif', body: 'Inter, system-ui, sans-serif', }, fontSizes: ['12px', '14px', '16px', '20px', '24px', ...], ... } export const light = { primary: '#4851f4', background: '#ffffff', nav: '#f8f8f8', border: '#deebf1', text: '#202224', ... } ``` Here, `base` contains some rules that will apply across all of our themes: things like spacing values, fonts, breakpoints etc. Defining these values here means that we can keep all of our styling consistent across the whole application. `light` contains the colours that will make up our light theme. Then, at the root of our application, we can make styled-components aware of this theme using a `ThemeProvider`. `src/app/App.js` ```jsx import React from 'react' import { ThemeProvider } from 'styled-components' import { base, light } from './themes' const App = () => { const theme = { ...base, colors: light } return ( {/* rest of your app goes here */} ) } export default App ``` Now, when writing a styled component, you will always receive your theme object as a prop: ```jsx import styled from 'styled-components' const Text = styled.p( ({ theme }) => ` color: ${theme.colors.primary}; ` ) Hello world! ``` ### Add a second theme and persist theme preference across sessions Now that we’re using a theme in our application, it is not much extra work to add a second. Define another set of colours: `src/app/themes.js` ```javascript export const base = { ​​breakpoints: ['768px'], space: ['0px', '2px', '4px', '8px', '16px', '32px', '64px', ...], fonts: { heading: 'Inter, system-ui, sans-serif', body: 'Inter, system-ui, sans-serif', }, fontSizes: ['12px', '14px', '16px', '20px', '24px', ...], ... } export const light = { primary: '#4851f4', background: '#ffffff', nav: '#f8f8f8', border: '#deebf1', text: '#202224', ... } export const dark = { primary: '#4851f4', background: '#1f2023', nav: '#27282b', border: '#303236', text: '#f8f8f8', ... } ``` Now we need to allow the user to choose a theme. We will store the current value in a React state variable. `src/app/App.js` ```jsx import React, { useState } from 'react' import { ThemeProvider } from 'styled-components' import { base, light, dark } from './themes' const themesMap = { light, dark } export const ThemePreferenceContext = React.createContext() const App = () => { const [currentTheme, setCurrentTheme] = useState('light') const theme = { ...base, colors: themesMap[currentTheme] } return ( {/* rest of your app goes here */} ) } export default App ``` Now from anywhere within your application, you can use the `ThemePreferenceContext` context to get the `setCurrentTheme` function and call it to update the current theme. Your styled components will pick up on this change and update accordingly. For example, you could do this with a select element: ```jsx setCurrentTheme(e.target.value)} > Light Dark ``` From here, hopefully you can see that it is trivial to add as many themes as you like - simply add a new set of colours, import them into your app, and make them available to be selected and stored in the state. Storing the current theme in React state is a start, but is only part of the solution. As it stands, this preference will not persist and will be reset every time the user refreshes a page or opens your application. Persisting the user's preference can be done in a couple of different ways: - **Save to a cookie:** By saving to a cookie, the user's preference is available both to the browser and the server. This is ideal if you are doing server-side rendering and need to know the theme preference to render HTML. If you SSR without taking the user's theme preference into account, you can be left with an annoying flash when a page loads because the server is sending the ‘default’ theme which is then changed on the client when rehydration occurs. - **Save to localStorage:** This is similar to using a cookie, but the value will only be available in the browser and not on the server. If you don’t need to know the theme preference on the server and everything is rendered on the client, this can be simpler. - **Save to a database:** If you are already storing user accounts or profiles in a database of some sort, then it might make sense to store their theme preference as a part of their account information. This method has the added advantage of persisting a user's theme choice across different devices. #### Server-side rendering From our application, we can save the user's preference to a cookie using a library like react-cookie. Here, we also add a new prop `initialTheme` to our App component, which will be important in a second. `src/app/App.js` ```jsx import { useCookies } from 'react-cookie' const App = ({ initialTheme = 'light' }) => { const [currentTheme, setCurrentTheme] = useState(initialTheme) const [, setCookie] = useCookies() const handleThemeChange = (theme) => { setCookie('themePreference', theme, { path: '/', expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365) // 1 year }) } ... } ``` Then, in our server, we can use the value of this cookie when we server-side render the initial HTML: `src/server/index.js` ```jsx import ... const app = express() app.use(cookieParser()) app.use(express.static('dist')) app.get('*', (req, res) => { const { themePreference } = req.cookies let app = '' let styles = '' const sheet = new ServerStyleSheet() try { app = ReactDOMServer.renderToString( sheet.collectStyles( ) ) styles = sheet.getStyleTags() } catch (e) { console.error(e) } finally { sheet.seal() } const html = ` ${styles}

Introducing public Git repository support. Simply paste any Git repository URL during creation to build and deploy in minutes. This means you can deploy any repository (public or private) from all version control platforms on Northflank regardless if the relevant App, OAuth or Webhooks have been set up.

Here's an example of deploying the minio repository with configured CMD override:

API changes

• Improved error message if a specified branch doesn’t exist
• Fixed URL schema not being correctly converted to OpenAPI specs
• Build settings object of either Dockerfile or Buildpack is now a required field
• Build endpoint now fetches and builds the latest commit if no commit SHA is specified

Other features & fixes

• Improved the visual appearance of build options, health checks and service search in pipelines
• Billing emails now explicitly say if the amount was paid or carried over to the next period
• Service header icon now stays consistent with the build or container status
• Fixed linking addons to a secret group on new creation forms
• Fixed an issue where you could input multiple variables with the same key on new creation forms
• Fixed an issue where realtime container lists would be rendered inconsistently
• Fixed an issue where updating a Dockerfile via the Northflank UI wouldn’t trigger a new build on repositories from self-hosted GitLab
• Fixed an issue where certain builds could not be deployed if the service branch was changed
• Fixed an issue where the Import backup button would stay disabled if there was an error importing the addon backup
• Fixed an issue where secret groups could not be favorited from the project dashboard
• Fixed some instances where long texts in components would overflow

We are excited to release our new resource creation forms to unify the creation flow for all resources, enable advanced configuration during creation and allow for future growth in features and capability.

• Unified style for creating all Northflank resources
• Select what resource you wish to create from the header
• Review your configuration by collapsing/expanding all sections at once or individually
• Configure all aspects on one page (including build type, environment variables, advanced network settings and more)
• Improved form validation highlighting any misconfigured or missing fields

Creating a MongoDB addon

Creating nginx:latest deployment service

Other features & fixes

• Added button to schedule a Northflank demo to our landing page 🎉
• Addon connection details now show full value on hover rather than a trimmed version
• Custom domain TLS certificates through 3-7th October have been reapplied due to missing chain
• Fixed an issue where some suspended GitHub installations would still appear in the repository selection dropdown

• API: update service security rules endpoint is now embedded in the update service ports endpoint. JS-client (v0.4.0) and CLI (v0.6.0) have been updated accordingly.
• JS-client (v0.4.0), CLI (v0.6.0): Simplification of get <resource> details endpoints. These endpoint can now be accessed without specifying details. E.g. get service, get addon
• JS-client (v0.4.0): Use plural for all list commands. E.g. list.plan(..) becomes list.plans(..).

Documentation

• Expanded Dockerfile and Buildpack build types to describe different build engines
• Improved guides to link custom domains with Cloudflare, Namecheap, OVH and NS1 DNS providers
• Expanded overview and example usage of the Northflank JS Client
• API Documentation now contains required RBAC permissions for all endpoints

Other features & fixes

• Improved automatic external image validation on paste and manual path edits
• Fixed an issue where you would have to manually redeploy a service after setting Basic Auth rules
• Fixed an issue where deleting a secret group would prompt you to enter your password again
• Fixed an issue where loading builds on a service with self-hosted GitLab would cause the page to crash
• Fixed issues where resuming deployment services with only private ports would fail and crash related pipelines
• Fixed an issue where branches wouldn’t load for self-hosted repositories if used in a team
• Fixed an issue where Dockerfile couldn’t be updated via the Northflank UI on repositories started from our templates

Northflank is pleased to release new versions of our JS Client (0.3.5) and CLI (0.5.2). In this release, we have added support for programmatic proxy support. It is now easier than ever to connect to multiple TCP and UDP workloads running in a private VPC with Northflank. This enables similar capability as tools such as kubectl forward, kubefwd, and cloudsql-proxy but now via proxy as code.

• Works with all TCP and UDP traffic
• Proxy multiple ports per service or addon
• Bind traffic to local IP addresses
• Automates local DNS to replicate production endpoints when relevant permissions are enabled
• Forward as many services and addons as you need with automatic port selection if you have multiple ports are already in use.
• Inherits existing Northflank RBAC permissions

const forwardingInfo = await apiClient.forwarding.forwardAddon({ projectId, addonId });

const connectionConfig = {
      port: forwardingInfo[0].data?.port,
      host: forwardingInfo[0].data?.address,
      user: process.env.USERNAME,
      password: process.env.PASSWORD,
      database: process.env.DATABASE,
    };

const connection = await mysql.createConnection(connectionConfig);

await connection.connect();

const results = await connection.query("SHOW TABLES;");

await connection.end();

await apiClient.forwarding.stop();

Other features & fixes

• Added logic for importing database backups from different database versions
• Added handling to prevent table pagination resetting to the first page after selecting an action item or when the table content was updated
• Improved handling of renamed and deleted repositories
• Fixed an issue where importing a MySQL database from an external backup would sometimes fail due to a permission error
• Fixed addon version header alignment
• Fixed formatting of list builds API endpoint where data would return an array rather than an object
• Fixed service URL overflowing the service header on mobile
• Fixed an issue where database backup could be deleted using the API whilst restore was still in progress
• Fixed an issue where creating a new deployment service would show an error page and had to be reloaded in some edge cases
• Fixed external image validation failing in some edge cases

We are excited to release support for switching the target Git branch in services via Build Options > Version control source settings. You now do not need to create a new service, pipeline or build service when you wish to simply change the branch. This was a highly requested feature and will improve the flexibility of our most accessible feature. In the future you will be able to change the Git repository.

• Continuous integration and deployment settings will take effect on the new branch.
• A new build will be automatically started for you if CI is enabled.
• Builds from previous branches can still be deployed, however CI is limited to the active source branch.

Other features & fixes

• Added handling for password managers to only suggest password saving and autofill when relevant
• API documentation now lists all possible values for enums
• Updated service and job headers to display the current build status
• Port detection now returns partial results instead of an empty array if the request times out
• Improved server time displayed on Job settings to be updated in real-time
• Improved duplicate detection and validation on environment variables and port editor forms
• Fixed commit icon on Latest commits disappearing after commits are loaded
• Fixed API returning 500 when creating an internal deployment service
• Fixed an issue where changing cron job from external image to an existing build service would pause the job
• Fixed an issue with MongoDB multi replica startup probe health check
• Fixed an issue where revoking self-hosted GitLab to allow personal use wouldn’t reflect in the existing services

Today we are excited to announce dynamic runtime configuration for Jobs on Northflank. It is now possible to configure environment variables and container image arguments for unique invocations of your job runs.

• Every invocation spawns a container with its own resources (current maximum 2 vCPU & 4 GB RAM)
• Unlimited execution time billed by the second of execution - pay for a powerful and limitless elastic compute only when you need it
• Optionally configure job retry limit and max execution time

Deploy a diverse range of workloads to Northflank with the ability to choose the most suitable runtime environment to get the best capability, cost and performance for your workload:

• Services: sustained runtime with elastic compute required to serve requests continuously
• Jobs: on-demand runtime with elastic compute to process background tasks as required

Example use cases

• Trigger a game server for a matchmade game
• Convert batch media files to different formats
• Generate and send PDFs to your users with configuration set via environment variables
• Calculate statistics and process complex data from databases

This feature is now supported in the Northflank API and CLI.

await apiClient.start.job.run({
  parameters: {
    projectId: "billing",
    jobId: "invoice-collection",
  },
  data: {
    runtimeEnvironment: {
      CUSTOMER_ID: "WhoR8gCYEF",
      CUSTOMER_EMAIL: "jane-doe@acme.corp",
    },
    deployment: {
      docker: {
        cmd: "node invoice.js $CUSTOMER_ID $CUSTOMER_EMAIL",
      },
    },
  },
});

API

• Added an example JS client code for Assign service to subdomain endpoint
• Added an API endpoint to abort builds
• Improved accessibility of the Northflank API Documentation
• Fixed an issue where description was required in the Create project endpoint
• Fixed an issue with Assign service to subdomain endpoint not updating the service if a certificate hasn’t been issued
• Fixed Get health checks endpoint not returning any data even if health checks were configured

Addons

• UI now displays a clearer warning for addons where an upgrade is recommended and addons that have an upgrade available
• Updated databases connection strings to work with Compass and and support both TLS/SSL query parameters with their enabled/disabled state
• Fixed an issue where backups wouldn’t work correctly for MongoDB with configured security rules

Template repositories

• Updated Rust template repository to bind to 0.0.0.0 so that the webserver is bound to both the etho and loopback device rather than only 127.0.0.1
• Improved auto port detection when template repositories are used
• Fixed an issue where GitHub wouldn’t create new repositories in some edge cases
• Fixed an issue where GitLab repositories would create as internal despite public being selected

Other features & fixes

• Aborted job runs now display an explicit status saying Aborted rather than Failed
• Updated build identifiers to be the human-readable name across the UI and API for easier team collaboration when referencing builds
• Updated Northflank GitHub actions so the link for View deployment takes you to your Northflank dashboard if there is no public service endpoint
• Improved VCS error handling to display more informative messages to the user
• Removed Auto DevOps on self-hosted GitLab instances so they don’t run default CI steps with GitLab runners
• Fixed an issue where build type (Dockerfile / Buildpack) would appear as unselected on existing services
• Fixed issues with environment diff editor showing local changes incorrectly and not displaying a warning when a team member made changes

We are excited to release Buildpack support alongside our Buildkit and Kaniko Docker build runtimes. Northflank’s mission is to allow developers to release any code with simplicity across any cloud provider. Buildpack support fits directly into the Northflank developer tools sandbox enabling you to immediately use end-to-end DevOps capabilities without a Dockerfile.

• Full compatibility with the Buildpack API specification
• Inspiration and building on best-in-class Buildpack implementations such as KPack and Tekton
• Secure runtime environment with rootless build & no requirement to mount a Docker socket
• Real-time log output and stage tracking with 30 days retention
• Choose from a number of Buildpack stacks with different capabilities that Northflank supports by default:
  • heroku/buildpacks:20 (suggested for most users)
  • heroku/buildpacks:18
  • gcr.io/buildpacks/builder:v1
  • cnbs/sample-builder:alpine
  • cnbs/sample-builder:bionic
  • paketobuildpacks/builder:tiny
• Supply custom Buildpacks which are applied within the selected stack by providing the URL or registry path
• All official and community maintained Heroku Buildpacks are supported
• Automatic DockerHub rate limit handling
• Reduce build times with caching support

Heroku Buildpacks on Northflank

To supply Heroku Buildpacks, use the Buildpack registry URL followed by namespace and name:
https://buildpack-registry.heroku.com/cnb/<namespace>/<name>

For example, to supply Heroku's Chromedriver in your service via the API include https://buildpack-registry.heroku.com/cnb/heroku/heroku-buildpack-chromedriver in the buildpackLocators array:

await apiClient.create.service.combined({
  parameters: {
    projectId: "default-project",
  },
  data: {
    name: "chromium-service",
    billing: {
      deploymentPlan: "nf-compute-10",
    },
    deployment: {
      instances: 1,
    },
    vcsData: {
      projectUrl: "https://github.com/acme-corp/chromedriver",
      projectType: "github",
      projectBranch: "master",
    },
    buildSettings: {
      buildpack: {
        builder: "HEROKU_20",
        buildpackLocators: ["https://buildpack-registry.heroku.com/cnb/heroku/heroku-buildpack-chromedriver"],
        buildContext: "/",
      },
    },
  },
});

When using the UI, specify the URL (such as https://buildpack-registry.heroku.com/cnb/mars/create-react-app-buildpack for create-react-app in your Build settings:

Other features & fixes

• Addons now display storage sizes in gigabytes by default
• Added support to specify project color to the API
• Disabled buttons to delete backups on addons that are restoring from a backup
• Fixed an issue where clicking on the addon instance bar would display a 404 page
• Fixed an issue where manual jobs could be saved as cron if you switched the job type tabs before saving
• Fixed an issue where the get addon details API endpoint would error in cases where IP policies were not configured
• Fixed an issue where the job data grid wouldn’t show the correct status for the first couple of job runs
• Fixed an issue where some older MongoDB versions wouldn’t support TLS

We are introducing a number of new endpoints available in the API and CLI as well as the JS client:

• Update network settings updates the addon TLS and External Access settings as announced last week
• Update security rules configures addon IP policy rules
• Get addon version details lists available upgrades and upgrade history
• Upgrade addon version upgrades an addon to a specified new version

The jobs UI was improved to give a clearer overview of all your jobs and their statuses, as well as show useful notifications and confirmation modals:

• Cron expressions now have labels showing them in human readable formats, such as Every 5 minutes or At 30 minutes past the hour
• Jobs data grid shows real-time deployment source, status, rules (such as deploying latest commits and builds) and whether the job is active or paused with explanations on hover
• Added confirmation modals for triggering job runs as well as pausing and re-activating a cron job
• Cron job dashboards now show a notification with a button to resume job scheduling if it is currently paused

Other features & fixes

• Added a createdAt field to the API response for addons, services and jobs
• Improved loading of job runs to be faster
• Improved loading of containers to be faster
• Service creation progress tracker now always sticks to the top to give you an overview of your configuration
• Fixed an issue where builds would not be found if a repository was renamed
• Fixed an issue where Create new dropdown menu would display unrelated items under On this page
• Fixed an issue where secret groups diff editor would suggest viewing differences after initial creation
• Fixed an issue where an addon backup could not be restored straight after another restore without refreshing the page

Today we are excited to announce public network support for Northflank Addons (databases such as MySQL, PostgreSQL, MongoDB & Redis and S3 compatible MinIO storage).

• Connect to your databases outside of Northflank
• Easily connect to popular tooling such as Retool, Segment and database UIs without needing to use Northflank CLI proxy
• External access is routed via Northflank’s highly performant DNS and load-balancers
• Traffic is encrypted end-to-end with TLS from client to the database
• Fine-grained network access controls for increased security

Northflank continues to level up the DBaaS experience across multiple popular OSS databases with consistent capability. You are now able to access your addons securely within the same project, via northflank forward and now for production workloads via load-balancers when workloads are deployed externally.

Public access can be enabled on addons deployed with TLS which can be configured in Network Settings. Once enabled, you will notice new external connection strings in Connection Details. You can configure them to be automatically inherited from your jobs and services.

Configurable security rules are also included in this release. Similar to IP and Basic Auth security rules that are available for services, you can specify certain IP addresses from which external ingress traffic will be allowed. We recommend always configuring IP policies as this brings another layer of security to your data.

Example connection scripts

// Connect to a publicly accessible MongoDB with inherited environment variables
// Inherit 'EXTERNAL_SRV' and 'DATABASE' via a Secret Group


import MongoClient from  'mongodb'

let db = {}
let client = {}

const MONGO_CONNECTION_STRING = process.env.EXTERNAL_SRV
const MONGO_DATABASE = process.env.DATABASE

const INIT_MONGODB = async () => {
    try {
        console.log('Connecting to database')
        client = await MongoClient.connect(MONGO_CONNECTION_STRING, { useUnifiedTopology: true });
        db = client.db(MONGO_DATABASE)
        console.log('Connected to database');
    } catch (err) {
        console.log(err);
    }
}

export default async () => {
    await INIT_MONGODB();
}

export { db, client }

// Connect to a publicly accessible PostgreSQL with inherited environment variables
// Inherit 'EXTERNAL_POSTGRES_URI' via a Secret Group

import pg from 'pg'
const { Pool } = pg;

const POSTGRESQL_CONNECTION_STRING = process.env.EXTERNAL_POSTGRES_URI

let client = {};

const pool = new Pool({
    connectionString: POSTGRESQL_CONNECTION_STRING,
})

const INIT_POSTGRES = async () => {
    try {
        console.log('Connecting to database');
        client = await pool.connect();
        console.log('Connected to database');
    } catch (err) {
        console.log(err);
    }
};

export default async () => {
    await INIT_POSTGRES();
}

export { client }

// Connect to a publicly accessible Redis with inherited environment variables
// Inherit 'HOST' and 'REDIS_MASTER_URL' via a Secret Group

import redis from 'redis'

const REDIS_CONNECTION_STRING = process.env.REDIS_MASTER_URL
const REDIS_HOST = process.env.HOST

let client = redis.createClient({url: REDIS_CONNECTION_STRING, tls: {
        servername: REDIS_HOST
    }});

const INIT_REDIS = async () => {
    try {
        console.log('Connecting to database');
        await client.on('connect', function() {
          console.log('Connected to database');
        });
    } catch (err) {
        console.log(err);
    }
};

export default async () => {
    await INIT_REDIS();
}

export { client }

• Addons can be upgraded between supported minor and major versions
• Guaranteed valid upgrade path between deprecated and latest supported versions
• Addons on deprecated/discontinued versions now display a visual indicator with a prompt to upgrade
• If there are multiple upgrades available the user can select the desired version
• A history of previous upgrades is available on the new Upgrade page

Other features & fixes

• Added a redirect after a resource is deleted to prevent displaying 404 pages
• Improved dashboard alignment on smaller screen sizes
• Improved validation formatting on the invite team members form
• Updated Job and Service creation headers to be consistent
• Moved Single Sign On into Account Settings from its dedicated page
• Fixed an issue where Create service button would not be disabled on uncompleted forms
• Fixed an issue where pull requests wouldn’t automatically get marked as closed in the UI for Bitbucket repositories
• Fixed an issue where the new repository name would persist after changing VCS provider on service creation from template

• Added human-readable branch & pull requests rules that are generated from your regex input
• Build service creation now automatically configures your repository’s default branch as a build rule

API Enhancements

• Responses now return detailed metadata so they can be handled without additional queries
• Added consistent upper case for endpoint names
• Added dedicated get deployment endpoint schema
• Changed public endpoints to be in line with authenticated endpoint responses
• Fixed deployment service creation failing to read a property correctly
• Fixed some endpoint responses not being formatted correctly (get deployment details, list regions, list plans)

// Sample 200 Response
{
  "data": {
    "external": {
      "imagePath": "nginx:latest",
      "registryProvider": "dockerhub",
      "privateImage": false
    }
  }
}

// Sample 400 Response
{
    "error": {
        "status": 400,
        "message": "Request failed payload validation - see details.",
        "id": "nf-invalid-request-body",
        "details": {
            "name": [
                "\"name\" is required. Received \"undefined\""
            ]
        }
    }
}

Other features & fixes

• Tweaked service creation form for better user experience
• Improved the user experience of automatic image path verification where a wrong path is pasted in
• Added external links to commits so you can compare file changes and see details in the VCS UI
• Fixed container bar not visible in solarized light theme
• Fixed max-width on service headers which caused the re-deploy button to be hidden behind a CD toggle
• Fixed advanced dropdowns displaying incorrectly in Firefox
• Fixed issues where configuring CMD override couldn’t be removed or it would disappear from the image settings page
• Fixed an issue where builds from GitLab repositories would fail if there were multiple commits in a short period of time
• Fixed GitHub container registry credentials not verifying correctly
• Fixed job list crashing occasionally where items are deleted
• Fixed an issue where an error would be displayed if service creation was submitted via hitting Enter rather than clicking a button
• Fixed an issue where repositories wouldn’t load correctly for self-hosted GitLab

• Pipelines now display linked custom domains in addition to generated Northflank domains on each service card
• Invite team members during team creation flow to get started quickly with your colleagues
• Hover on build services in the pipelines sidebar displays the linked repository
• Job runs UI now displays if the run was triggered by the cron schedule or triggered manually by the user

Other features & fixes

• Added error codes and request body descriptions across all API calls
• Environment variables are now always passed as strings to prevent accidental trimming/rounding when supplied as a number
• Added support for displaying a company VAT ID in billing where applicable
• Refund status is now reflected on refunded invoices in billing
• The applicable VAT rate is displayed through current usage and invoice views
• Saving service configurations now skips initiating a redeployment if no effective change was detected
• Updated help popovers in addon connection details
• Pressing Esc on help popovers now closes them
• Improved cron job syntax checking to prevent multiple spaces
• Improved handling when generating unique DNS identifiers preventing partial word generation
• Fixed an issue where some GitHub organisation commits wouldn't load in the UI
• Fixed an issue where the service list would crash after deleting some services

Today, we are pleased to release our new documentation experience - making it easier for you to quickly understand Northflank features and how to get started step-by-step.

• Select between a dark and light theme to match your Northflank UI 🌓
• Getting started is great when you're just starting out - it will guide you from setting up your account with Git and creating your first service, pipeline and all the way to deploying with custom domains
• How-to guides help you configure your workloads in all stages of the DevOps workflow (Build, Run, Release, Observe and Scale) with in-line explanation and sane defaults, expanding on advanced topics such as addons (databases and persistent storage) or network security and encryption
• API and CLI documentation provides an API reference to build applications integrated with Northflank - example code snippets are available for the Northflank CLI, JS client and API calls (curl, JavaScript, Python & Go)
• Updated help popovers in the UI to reflect the new documentation
• Improved fast search across both App and API docs 🔎

Other features & fixes

• Create template repository services with GitHub, Bitbucket and GitLab (including self-hosted instances) on both users and team accounts (previously only personal GitHub accounts were supported)
• Added support for importing addon backups from links that require a redirect (e.g. Dropbox)
• Added an explicit message if automatic port detection couldn't find any ports
• Hovering on deployment services now highlights the linked build services on pipelines
• Increased a feedback input limit to 1200 characters
• Added a starter template for Rust
• Added an option to add unlinked VCS via Git selection dropdowns rather than having to navigate to Account Settings
• Fixed an issue where container icon and status sometimes wouldn't match
• Fixed an issue where Docker Credentials couldn't be selected if the image path was missing or was copied and pasted into the modal
• Fixed an issue where private images would sometimes be labeled as public in the UI
• Fixed the instance selector not rendering on logs page while logs loading
• Fixed pull requests showing 'invalid date' for the first couple of seconds in the UI
• Fixed an issue where accepting a team invite via an email invitation link would fail

We are excited to release a new version of the Northflank JavaScript API client alongside another release for the CLI. To install the API client in your Node JS projects setup with npm i @northflank/js-client or yarn add @northflank/js-client and enjoy full native IntelliSense & type suggestion support in your IDE of choice.

The API client provides an easy way to provision and maintain infrastructure as code and integrate your applications with Northflank. Simply get started by generating an API key in your team or account settings.

The new version simplifies the user experience and removes some previous complexity:

• Client no longer requires .endpoints and .call

  • apiClient.endpoints.create.project.call becomes apiClient.create.project

• Client parameters passed to the API call follow a new format

  • {parameters: {..}, data: {..}, options: {..}}

• API Documentation now shows example JS client code snippets for all endpoints

Example usage

import { ApiClient, ApiClientInMemoryContextProvider } from "@northflank/js-client";

(async () => {
  // Create context to store credentials.
  const contextProvider = new ApiClientInMemoryContextProvider();
  await contextProvider.addContext({
    name: "default-context",
    token: "<api-token>", // Use generated API token
  });

  // Initialize API client.
  const apiClient = new ApiClient(contextProvider);

  // Retrieve list of projects and log to console.
  const { response: { projects } } = await apiClient.list.project({});
  console.log(projects);

  // Create a new project.
  await apiClient.create.project({
    data: {
      name: "default-project",
      region: "europe-west",
      description: "Default project description",
    },
  });
})();

Other features & fixes

• Changed layout of our blog & changelog to display the most recent item at the top and added infinite scrolling
• Added container statuses to influence overall service health, indicating in real-time if there is an issue with one or more containers
• Limited maximum width of forms across the UI to make it a better experience on 4K or widescreen displays
• Services now show an explicit error if the GitHub, Bitbucket or GitLab installation is missing
• Fixed API addon backups endpoints not parsing path parameter correctly
• Fixed an issue where editing security rules would sometimes crash the page
• Added a warning if two or more IP security rules use the same IP address
• Fixed an issue where a Dockerfile wouldn't get fetched correctly in some edge cases with Bitbucket repositories
• Fixed an issue where you'd get redirected to a non-existing page after adding a new subdomain

We added a feedback form to the UI which you can use to share feedback, suggestions or any issues. You can also upload attachments such as screenshots or screen recordings.

The addon connection details inheritance was improved to prevent adding duplicate aliases and the UI now displays all aliases in a nested way, so it becomes clearer which key names are used for which connection detail.

Other features & fixes

• Improved automatic port detection to detect ports declared as variables in the Dockerfile
• Fixed an issue where updating port configuration would trigger two restarts
• Fixed an issue where addon connection details wouldn't get inherited if other projects used the same addon name
• Fixed an issue where the image settings page would crash after inputting quotes in the CMD override
• Fixed an issue where pressing enter on some forms would disregard changes rather than saving
• Fixed an issue where a service couldn't be created after switching between service types
• Fixed a validation issue of the environment editor after removing invalid fields
• Fixed issues with validating and switching external registry providers after they have been configured
• Fixed Dockerfile validation preventing from creating service if Dockerfile was originally missing
• Fixed job run durations displaying wrong timestamps for the first couple of seconds

We are excited to announce Northflank Addons are now available to all users and teams in supported regions. Deploy highly available persistent workloads such as PostgreSQL, MySQL, Redis, MongoDB, and MinIO in seconds.

Northflank Addons is our DBaaS solution, bringing a consistent and comprehensive operator pattern across multiple popular databases and object stores to any Kubernetes cluster. Create, backup, scale, secure and observe stateful workloads via UI, CLI or programmatically via our API or Javascript Client.

// example code snippet provisioning a stateful MySQL workload
// with 1 replica using @northflank/js-client

const myAddon = await apiClient.create.addon({
  project: "my-amazing-project",
  payload: {
    name: "my-amazing-database",
    description: "my amazing database for my amazing project",
    type: "mysql",
    externalAccessEnabled: true,
    tlsEnabled: true,
    version: "8.0.25",
    billing: {
      deploymentPlan: "nf-compute-100",
      replicas: 1,
      storage: 1024,
    },
  },
});

• Provision database read and write replicas in seconds
• Select from a range of supported versions
• Cost-effective vertical and horizontal scaling
• Low latency internal networking with your micro-services and applications
• Secure internal network isolation within your Northflank project
• Easily provision with TLS for secure network traffic
• Monitor and observe all addon containers via logs and metrics
• Scale storage size rapidly so you never run out of disk space
• Link addon connection details to secret groups for automatic inheritance of environment variables into jobs and services as announced here
• Backup via UI or API and restore your databases from a Northflank backup or an external source
• Manage and interact with addons via the Northflank API and CLI
• Securely access databases on your development machines via northflank forward

You are now able to tail and search logs across all containers within a Northflank service, job, build or addon. This levels up observability when deploying and debugging in a highly available production environment and applies to:

• Logs from containers deployed in a service
• Logs from CI tracking build progress across parallel builds
• Logs from parallel job runs triggered via cron schedule or API trigger
• Logs from database masters and replicas
• Logs from terminal or running containers (up to 30 days of retention)
• Logs from backups and restores

Due to increased load on our logging backend, we have implemented a fallback when WebSockets are exhausted. If Northflank is unable to establish a real-time connection to the queried log stream, it creates a static HTTP query & returns the relevant log messages, putting your client into an offline state.

You will always be able to retrieve logs irrespective of load on our real-time logging infrastructure, and you can attempt to reconnect to the real-time stream via a button in the UI.

Other features & fixes

• Addons header now show status, containers and meta information
• Addon connection details inheritance now prevents setting duplicate names
• Added addon port to the connection details
• Added real-time updates to the project list when permissions are changed
• Jobs with external deployments can now be created even without a linked Git account
• Improved the UI of build deployment modals inside Pipelines
• Fixed Northflank logo not loading on template repositories
• Fixed a bug where service couldn't be created after deleting a custom port configuration
• Fixed several line breaks and now showing abbreviated names of branches and PRs if they're too long
• Fixed an issue where API Templates couldn't be deleted
• Fixed favouriting container registry credentials

• Build logs now throw an explicit error if the Dockerfile couldn't be found
• Small tweaks to the Billing and Resources UI
• Fixed flickering of the Edit deployment modal when switching deployment source tabs
• Fixed the project list not updating in real-time when restricting users from projects
• Fixed real-time reloading of new branches, added refresh buttons for manual reload
• Fixed an issue where some commits would be delayed by ca. 20 seconds before appearing in the UI
• Fixed some Bitbucket commits not building automatically with CI enabled
• Fixed commits showing as deployed before a build is completed
• Fixed handling member removals if they linked their Git to the team
• Fixed job durations and start times not displaying correctly sometimes
• Fixed a form validation issue with the secrets dif editor
• Fixed an error where backups could be created for addons that are still provisioning
• Fixed crashing the instances page if all three health checks were added to the service
• Fixed infinite loading on pages with deleted API tokens
• Fixed issues with self-hosted VCS webhooks
• Fixed occasional lagging of the Dockerfile editor

We have redesigned pipelines for increased accessibility and user experience. Each service now shows the status of its containers and the public URLs for easy navigation.

Other features & fixes

• Unified wording across the UI
• Added a link to open the selected Git repository during service creation
• Confirmation modal to remove a team member now displays the member's name
• Ports now use internal IDs to prevent removing security rules (Basic authentication and IP policies) when updating port names
• Fixed an issue where Docker command override could not be cleared
• Fixed an issue with updating ports on subdomains from Settings
• Fixed wrong timestamps on the job runs list
• Health checks are now displayed on the Containers page

Users and teams can now edit profiles and upload avatars on a newly designed profile page. It also displays any account limits such as the number of free services, instances per service or parallel builds.

The user experience of adding new Docker credentials for external registries has been enhanced, allowing you to get started with GitHub Container Registry (ghcr.io), GitLab Container Registry, Google Container Registry (GCR) and Amazon Elastic Container Registry (ECR) within seconds. The image path is automatically validated and relevant meta information is displayed.

Other features & fixes

• Made the PRs and branches list consistent across the UI
• Team members page now shows when each member joined the team
• Fixed several UI issues causing strange behaviours on 13" screens
• Fixed an issue where secret name duplicates would be detected across the whole account rather than just projects

• Create deployment services without a linked Git account - this is handy when you only want to deploy images from external registries
• Service creation now informs you if there are any missing or invalid fields for networking and ports
• Domains in service headers now update in real-time if port names change
• Custom domains show detailed errors and warnings if validation fails whilst configuring new domains or subdomains
• Individual job runs can now be cancelled either via the UI or API

Other fixes

• Fixed wrapping long branch names in pipelines
• Fixed the team selector showing an empty space if there was only one team
• Fixed an issue where you couldn't edit a GitHub installation if linked to a personal account
• Fixed an issue where a combined job wouldn't display its repository in the resource data grid
• Fixed an issue comparing local & remote changes via the diff editor displaying some incorrect fields in project secrets

Northflank CLI now supports UDP port forwarding in addition to existing TCP & HTTP protocols. This enables secure forwarding of UDP traffic running within your project firewall to your local machine. UDP traffic is essential for real-time communication, media and game servers, VoIP, DNS and many other applications.

This unique capability has been added in conjunction with wide-ranging security and runtime improvements, prompting us to migrate from Kubernetes API port-forward due to its limitations in only supporting TCP traffic. In summary, Northflank can power many more applications, furthering our mission to deliver a sandbox of developer tools that get out of your way.

Other features & fixes

• Cron jobs UI now shows a warning if the job is paused
• Form headers are now consistent across different views
• Advanced options inside forms are now hidden in a dropdown by default
• The modal to link self-hosted VCS was changed to be on its own page, rather than a popup modal
• Fixed an issue where invalid credentials could be saved
• Fixed an issue where the online status of other team members wouldn't show correctly sometimes

Lists across the Northflank UI are now user-configurable and have been upgraded to match the increased functionality of Northflank over the last 12 months. Resource data grids now give immediate observability of your projects and the status of your resources.

• Alphabetic sort of the table by a selected key, sort by date or status
• Filter content by a string search or select dropdown
• Set your preference of which columns to display, hide, or sort by
• Lists continue to work across all devices including mobile

Other features & fixes

• Northflank now stores your last user/team context in local storage so when you open the UI again you can continue where you left off
• Fixed an issue where a user/team switch popover would be inaccessible if viewport height is small
• Fixed an issue where self-hosted VCS settings wouldn't display the application ID correctly
• Fixed an issue where automatic port detection would display some private ports as public for some deployment services

Secret groups can now inherit environment variables from your addons. This enables easy and safe access to connection details in services and jobs without the need for error-prone manual copy and paste. Addon variables can be linked to a secret group via the UI on both the addon and secret group pages.

• Control which connection details get injected into your runtime from a list of available variables
• Northflank suggests default variables to inherit if you're not sure which ones to select
• You can define additional aliases for each variable to match your software requirements
• On your services and jobs, you are able to see all inherited environment variables and which ones take effect
• Control the order of inheritance between conflicting keys by defining a priority per secret group
• Variables defined on a service or job level always take priority over inherited values (the UI also shows a warning to prevent accidental overrides)
• Fine-grained control on which services and jobs will the inheritance apply

Other features & fixes

• Updated addon offerings to the latest versions
• Fixed an issue where connections between services in the pipeline view wouldn't update during promotion
• Fixed an issue where VCS source wouldn't load on the 'edit deployment' modal for self-hosted services
• Fixed an issue where the environment editor would convert arrays into objects

We improved our integration with GitHub, GitLab and Bitbucket to show updates in real-time as you commit your files, update your branches and manage pull requests. The UI automatically reflects any changes you make, such as changing a branch name or closing a PR.

Real-time Git integration rapidly improves the speed and performance of the UI and pages are still accessible even during Git outages and respect the permissions of the Git providers (e.g. revoking access to a repository will prevent new data from being ingested or viewable for removed accounts).

Other features & fixes

• Added an infobox to the billing dashboard that shows warnings for expiring cards and overdue invoices
• Extended support for additional syntaxes for automatic port detection
• Networking rules for deleted/renamed service ports are now removed immediately
• Fixed an issue where a cursor and copy highlights wouldn't show on code editors
• Fixed an issue where an error would sometimes show for correctly formatted JSON in environment editors
• Fixed an issue where empty keyfiles would be accepted when creating environment credentials

You can now easily switch domains between services deployed in different regions without having to update your DNS records with your provider. Once your domain is linked to Northflank, you have the full control to move it across services & regions. All traffic gets redirected to the new region automatically.

We also made it easier to deploy specific commits from a builder onto a scheduled job, which now matches the experience with deployment services. You can use the Build Selection modal to select a specific build or commit from a branch/pull request.

Other features & fixes

• Improved syncing between Kubernetes clusters and the Northflank control plane, increasing reliability and enabling automatic incident recovery for event streams
• Added the ability to delete individual pods via the UI
• Free services will now only have at most one running pod rather than completing a full rollout restart
• Environment editor pages now display a warning if they are open in multiple tabs and allow you to compare changes between versions
• Job run view page meta information is now displayed in a reactive manner
• Optimised performance of Northflank’s multiplayer experience to reduce overly eager React re-renders which caused issues when a larger number of active tabs were in use
• Fixed inconsistent websocket load-balancing in the UI when using the Brave browser. Thanks @Ben!
• Fixed an issue where successful build and promotion events would trigger two parallel deployments in certain circumstances, this resulted in excess containers for a short time and increased duration of a completed deployment

We improved the GitHub integration to display Northflank combined services deploying your repositories in the GitHub UI. This is especially helpful when rapidly iterating and reviewing changes on feature branches. We will be evaluating this integration for deployment services over the coming weeks, too.

Other features & fixes

• Docker registry credentials can now be updated without triggering restarts in affected services and jobs
• Job cron schedule editor now shows the server's current time to ease scheduling
• Added a Rust Nickel.rs repository to service templates
• Added a confirmation modal before deleting team roles
• Added a copy to clipboard button on basic auth credentials in network security rules
• Fixed an issue where the role permission selector would not correctly display granted permissions if the form was disabled
• Fixed an issue where the team admin role wouldn't have access to update domains by default
• Fixed an issue where deleted ports would still appear as part of security rules
• Fixed an issue where a build wouldn't start automatically after service creation in certain scenarios
• Fixed an issue where 1Password would suggest creating a new password instead of filling out the existing one on password confirmation modals in the UI
• Fixed an issue where the user would be redirected to a non-existing route on secondary tabs when finalising their account
• Fixed an issue with assigning subdomains to a port via the API

We redesigned the user and team dashboards to include account achievement steps, which guide developers to link their Git accounts, create projects and services, add pipelines and domains, as well as invite team members with various permissions.

Other features

• Added links to documentation, changelog and feedback within the platform
• Added global messaging for version control linking
• Added support for ${} syntax for port variables in Dockerfiles
• Added connection details for Minio and Redis with example CLI commands
• Increased support for APEX or flattened CNAMEs that are actually subdomains
• Improved colours, contrast and code editors across all themes to make the appearance consistent

Fixes

• Increased number of retries when environment fetching is unavailable
• Fixed permissions for listing API key templates that the user can access
• Fixed DockerHub and Quay pull rate limits
• Fixed an issue where addon would move from 'deleting' to 'failed'
• Fixed an issue with listing branches from self-hosted VCS

Login to your account using single sign-on for Google, GitHub, Gitlab and Bitbucket. You can enable and disable SSO for each provider in your Account Settings for increased security.

User Experience

• 'Create new' button was redesigned to work without a selected project when adding services, jobs, addons, pipelines or secret groups - it now shows a list of all your projects for you to choose from
• Code editors in the UI now change syntax highlights based on the selected theme

Other features & fixes

• We improved onboarding for first-time users - guiding them to configure their settings, link Git and create their first project
• Fixed an issue where a service couldn't be scaled vertically if configured to use spot resources
• Fixed an issue where addon storage scaling would return slightly different sizes on different providers (e.g. requested 20000Mi leads to 20Gi, which is 20480Mi)

Customise your Northflank experience to match your IDE or preferred colour style. We are pleased to introduce Light, Blackout, Solarized Light, Solarized Dark and Dracula (JetBrains IDE) in addition to the default Northflank theme.

Other popular themes will be added over the coming months as we gather user feedback. Let us know if there are any specific ones you would like to see.

You can change your theme in user account settings, it applies in real-time to all your open Northflank tabs on all devices (including mobile) and will also affect your view across teams.

Other features & fixes

• Improved platform notifications to be more consistent and user friendly
• Fixed an issue where addons backups list wouldn't show if all backups were deleted
• Fixed an issue where creating a Docker credential secret would redirect back to the credentials list instead of the newly created secret
• Fixed an issue where the commit list wouldn't update redeployment buttons on the deployed commit in certain scenarios

Custom Docker Registries

You can now deploy images from any custom Docker registry on Northflank, no longer restricting you to GitHub, GitLab, Docker Hub and Google Container Registry.

• Bring your self-hosted registries and conveniently store credentials on Northflank for secure and rapid access
• Automatic detection of public/private visibility & registry authentication scheme, and login with username & password or .docker.config

Fine-Grained RBAC

We have redesigned the Role-Based Access Control (RBAC) for teams and APIs.

• Teams can create varying permissions and apply them to specific projects or team members as required
• Permissions update in real-time across the Northflank UI, removing or adding relevant components dynamically
• RBAC provides fine-grained security for you and your team across the Northflank UI, API and CLI
• RBAC also applies to the 'northflank forward' CLI command, giving you control of which services and addons can be forwarded for local development

Other features & fixes

• Team owners can now transfer ownership to another team member
• Jobs (cron or manual trigger) can now be created with a Northflank build service as the deployment source
• Moved 'Recent builds' card higher in the dashboard for instant observability
• Addons 'redeploy' and 'pause' buttons are now only enabled if the addon is running or scaling
• Fixed an issue causing some build rules validations to fail

We've added live notifications to warn you if a team member may be editing the same environment variables, build arguments or project secrets. If a change is made while you're editing the same settings you can compare differences between your edits and the remote version, and decide if you want to over-ride them. The difference editor also gets real-time updates, so you can see new changes straight away.

Other features & fixes

• New login and sign up pages
• You can now manually pay a failed invoice with a new or saved card
• Fixed an issue where log lines would be copied in reverse
• Fixed an issue causing some team invitations to be rate-limited
• Fixed an issue causing commits to not update remote VCS check status in real-time when build state changed on Northflank

We are excited to introduce our new marketing site! The experience is now more consistent with the Northflank platform, and it highlights Northflank's capabilities at a glance.

Developer Experience Improvements

• Released a new version of the Northflank API client with 8 new endpoints
• Redesigned docker image settings overview to be clearer and compact
• Added a 'copy to clipboard' button for API tokens with a highlight of the last 4 digits
• Improved UX of adding self-hosted VCS and you can now link directly to specific VCS setting modals

Other features & fixes

• Added an option to pay invoices manually if the automatic payment fails or requires additional verification
• Various improvements to API error responses for easier debugging
• Fixed an issue causing relinking Git from Pipelines to fail
• Fixed an issue with JSON view in Secrets sometimes rendering incorrectly
• Fixed an issue with container registry credentials sometimes not loading
• Fixed an issue with GCR credentials verification failing in certain scenarios

This week, we introduced some new features and fixed several bugs:

• Automatic port detection now suggests removing unused ports
• When connecting domains to services, the service selection dropdown is now grouped by project
• Added duration and container runtime for manual and cron job runs to the UI
• Added new API for stateful addons (abort backup, abort restore, delete backup, download backup endpoints)
• Added automatic retrigger of log search after timestamp ranges are updated
• Added favouriting pipelines, secrets and Docker credentials
• Fixed an issue where log lines would display as objects instead of the message string during log search between specific timestamps
• Fixed an issue causing random name generation to exceed the maximum character limit
• Fixed an issue causing a page to crash after accepting a team invite for the invitee
• Fixed an issue causing the job restart modal to crash if another team member opened and interacted with it
• Fixed an issue causing interactive deployment pipelines to crash when removing a service from a stage in certain circumstances

Here is a summary of what we worked on this week:

• UI design fixes and tweaks - Northflank now works well on mobiles and tablets
• Enabled proxy and mTLS on jobs and cron jobs to enable communication with other services and addons in your project
• Platform prompts automatic port detection after your Dockerfile has been edited via the Northflank UI
• Updated API to handle new logic of adding domains and subdomains, improved error handling
• Team members now have the option to leave teams of which they are not the owner
• Fixed an issue that would sometimes display an error after creating services from template repositories
• Fixed an issue when viewing logs for an addon would sometimes display logs for another addon in the same project

Adding custom subdomains

As we announced recently, we streamlined the process of adding and verifying custom domains. We have now also improved the Add domain modal that guides you through the process and automatically checks if the TXT verification record has been added.

Improved billing user interface

• Compute plans are in a horizontal table view allowing you to easily compare resources and pricing
• Resources page displays a price breakdown showing cost per hour, month and a selected number of replicas
• The invoice list displays the status, date issued, invoice period and amount in a clearer layout
• Other minor UI changes to improve the visibility of critical billing information

Other Improvements and Fixes

• Added TLS certificate status to Account Settings - Domains page
• Account Overview page now also shows self-hosted VCSs under Git integrations
• CLI upgrade now gives more control over addons (you can now use commands such as import backup or pause addon)
• Added filtering of MongoDB addon logs to hide health check connections being created to reduce noise

This week, we're excited to showcase the Northflank API & CLI working in parallel. We used our API to securely deploy a game server and connected to it using the Northflank CLI and TCP proxy - creating an example of infrastructure as data.
Check the video below to see this in action:

• First, we create a new project in the Northflank UI and run an API call that creates a deployment service from an external Docker image itzg/minecraft-server:latest, exposing it on an internal port 25565
• Once the service starts, we run a northflank forward CLI command that exposes the service locally
• After the Minecraft server has spun up, we connect to it ready to start playing - you can see the logs coming up in real-time in the Northflank UI

Other Improvements and Fixes

• Domains Ports dropdown now only shows the relevant public entries
• Improved handling of backup and restore of databases resulting in faster processing and fixed an issue with restoring database users and rights
• Updated documentation context to cover newly added features
• Updated MinIO connection strings to work for JS clients
• Fixed a couple of frontend mobile view bugs
• Fixed Edit Deployment modal crashing on internal services
• Fixed a bug causing image verification to fail if it contained a numeric value
• Fixed a bug causing log filtering by time range to fail
• Fixed a bug causing docs search not loading found pages
• Fixed a bug causing northflank forward CLI command to fail occasionally

Deployment Source Overview

Deployment services now have an improved visual display of the deployment source, whether deploying Docker images from the Northflank container registry or a public/private external container registry.

Pipelines

To configure your services using Pipelines, you can drag and drop deployment services from the side menu to Development, Staging or Production. To add a build service, select it from the menu and choose the build you want to link from the modal. We've improved the UI & UX to make Pipelines more accessible.

Improved Port Detection

Northflank automatically detects ports from your Docker images. We've added a modal that lets you review and change the suggested ports before adding them to your services. You can detect ports during service creation or from the Ports & DNS tab in your existing services.

Hostname in Addons Connection Details

In addition to connection strings and secrets for addons, we've added a connection detail with a hostname of the main replica that handles write operations. This can be used for local debugging and development in applications such as DataGrip, Robo3T and SQL Workbench. Use the Northflank CLI to securely forward addons for local access and development. Alternatively continue using the full admin or data connection strings to connect to your addons normally.

Other Improvements and Fixes

• Added image path validation for versions of Docker images, shows a warning if you didn't add any version or if it doesn't exist
• In addition to us.gcr.io and eu.gcr.io, we've added support for gcr.io and asia.gcr.io Google Cloud Container Registry regions
• Following GitHub's new registry URL we've updated the hostname from docker.pkg.github.com to ghcr.io
• Fixed an issue causing Environment Variables not saving after switching between JSON and Table view
• Fixed an issue causing build duration to display unknown if it was zero seconds

Northflank allows you to easily bring your custom domains to your account. We received feedback that connecting your domains and then adding them to a service was too difficult, so we revised this workflow to be more streamlined:

• Add your domain in Account Settings - Domains and verify it with your provider by adding a TXT record
• Create subdomains on Northflank and add appropriate CNAME records in the DNS settings
• Start linking services & ports from the dropdown or in the Ports & DNS tab of your service

Once your subdomains are set up you can change the linked ports and services without having to update your DNS records again. You can use custom domains across all projects.

Key features:

• Access your services deployed at acme-domain.com, acme-domain.com/microservice or microservice.acme-domain.com
• Northflank handles load balancing of services to the relevant region & cloud provider to ensure availability
• Northflank rapidly creates and regenerates Let's Encrypt certificates for free on all your domains, ensuring certificates are in date and connections stay secure
• Domains can also be managed via the Northflank API and CLI

Beside custom domains, Northflank now exposes your public services as a subdomain of code.run - the URL follows the structure of [port-name]--[service-name]--[project-name]--[account-dns-identifier].code.run.

Demo to GitLab

Last week, we gave a demo to Sid Sijbrandij (Co-founder and CEO at GitLab) that was streamed live. Watch the recording on YouTube or below.

As introduced recently, Northflank supports deployments from external private registries such as Google Container Registry, Docker Hub, GitLab and GitHub.

To make the authorisation easier, you can now save Docker credentials in your account and reuse them across services and jobs.

When creating a new Docker credential, select your Registry provider and login using one of the following methods:

• Username and password
• Username and API token
• Username and Personal Access Token for GitHub
• keyfile.json for Google Container Registry
• Directly supply your Docker config.json file

Northflank will automatically encode your login details in base64 for registry authorisation.

Docker credentials can be reused across all projects or restricted only to selected ones. You can always manually override your credentials when creating jobs and services.

To add your credentials, navigate to your Account settings - Docker - Add credentials.

You can then use your saved credentials when you create a new job or service with deployment from an external image.

Environment variables provide a secure way to store your keys, tokens, paths and other secrets used in your applications. They can be added for services and jobs under the Environment tab.

Projects are groups of services, jobs and addons. With Project Secrets, you can now set environment variables on a project level which will save time and ease variable management if several of your applications depend on the same values.

• Apply Project Secrets to the whole project or restrict to one or more services & jobs
• Create more Project Secrets and set priorities to define which ones take precedence
• Setting variables directly in the service or job will always have priority over Project Secrets

Secrets are encrypted at rest and only decrypted before being merged and injected into your runtime environment.

To create your Project Secrets, navigate to your project and select Secrets from the Dashboard or Sidebar.

Project Secrets are also fully supported via the Northflank API & CLI (introduced in this article) with team RBAC included.

Here is an example of creating Project Secrets using the Northflank API:

const payload = {
  name: 'My Project Secret',
  description: 'Environment variables for my project',
  secretType: 'environment',
  priority: 10,
  restrictions: {
    restricted: false,
    nfObjects: [
      {}
    ]
  },
  data: {
    API_KEY: '****',
    API_TOKEN: '****'
  }
}

const response = await fetch(NORTHFLANK_API_ENDPOINT, {
  method: 'POST',
  headers: {
  	'Accept': 'application/json',
  	'Content-Type': 'application/json',
  	'Authorization': `Bearer ${NORTHFLANK_API_TOKEN}`,
},
  body: JSON.stringify(payload),
});

const json = await response.json()
console.log(json)

// => Created secret My Project Secret

You can now leverage the full capabilities of the Northflank API using our Node.js and JavaScript API client. Full typing support is available for TypeScript.

Install the Northflank API client using npm i @northflank/js-client or yarn add @northflank/js-client. You will need to create an API token in your user or team account. Full API documentation is available here.

Use the following import statement to include it in your project

import ApiClient, { ApiClientInMemoryContextProvider } from '@northflank/js-client';

Initialise the API client

(async () => {
    // Create context to store credentials
    const contextProvider = new ApiClientInMemoryContextProvider();
    await contextProvider.addContext({
        name: 'test-context',
        token: '<api-token>', // Use API token generated in the Northflank UI
    });
    
    // Initialize API client
    const apiClient = new ApiClient(contextProvider);
})();

Create a new project

await apiClient.endpoints.create.project.call({
		quiet: true,
		payload: { name: 'test-project', region: 'europe-west' },
	});
// => New project test-project created

List all projects

const projects = await apiClient.endpoints.list.project.call({ quiet: true });
console.log(
		'Projects:',
		projects.response.map((project) => `${project.name} ${project.internalId}`)
	);
// => Listed all projects successfully

Create a combined service

const combinedServiceCreationResponse = await client.endpoints.create.combinedService
  .call({
    project: 'default-project',
    payload: {
      name: 'My awesome combined service',
      description:
        'A combined service created with the Northflank API Client',
      billing: { deploymentPlan: 'micro' },
      deployment: { instances: 1 },
      vcsData: {
        projectUrl: '<https://github.com/northflank/my-project.git>',
        projectType: 'github',
        dockerFilePath: '/app/Dockerfile',
        dockerWorkDir: '/app',
        projectBranch: '/feature/changelog',
      },
      ports: [
        {
          name: 'port-1',
          internalPort: 3000,
          public: true,
          protocol: 'HTTP',
        },
      ],
    },
  })
  .catch((err) => err.message);
// => Created a combined service with ID my-awesome-combined-service

Scaling a service

const scaleServiceResponse = await client.endpoints.scale.service
  .call({
    project: 'default-project',
    service: 'my-awesome-combined-service',
    payload: {
      instances: 10,
      deploymentPlan: 'large',
    },
  })
  .catch((err) => err.message);
// => Service scaled successfully

Teams can now add their self-hosted instances of GitLab to Northflank in addition to the SaaS offerings of GitHub, GitLab and Bitbucket.

To get started, create a new application in your self-hosted GitLab instance. Enter the application name, select the API scope and paste the redirect URI as https://app.northflank.com/api/integrations/git/finalize.

Then navigate to your team on Northflank and select Add a self-hosted VCS under Team Settings - Integrations - Git. Choose your name, enter your GitLab URL and paste application ID and secret from the created application.

Once added, you can use your self-hosted GitLab to create combined or build services and jobs:

• During service or job creation, select your self-hosted GitLab from the dropdown
• Continuous Integration will build your code on every push
• With build services, you can build merge requests and branches
• You can add multiple self-hosted GitLab instances to your account

🎉 Here is an example of a successfully deployed and running NodeJS Express app:

Introducing improved API documentation which now includes documentation for the Northflank CLI covered last week. To get started, create an API token for your user or team account.

Documentation Features

• Choose from light or dark theme 🌗
• Search is super fast across all content and powered by Algolia 🔎
• Customise your layout and see API code snippets in curl, JavaScript, Python and Go 🚀

You can access the docs here.

We have worked on a redesign and made significant improvements to the UI & UX of the platform. The layout is more uniform making it even easier to navigate around your infrastructure on Northflank.

Logs & Metrics

We have improved real-time logging and long-term storage for all jobs, services and addons resulting in better observability of your applications. This capability is perfect for debugging in production with a powerful include/exclude REGEX and text-based search that works in live-tail and over specified time periods.

In addition to the UI and API, you can now interact with Northflank using a Command Line Interface. Local deveploment becomes even easier with the ability to proxy your remote databases and services to your machine. The Northflank CLI comes with RBAC so you can securely share services with developers in your team.

Install the Northflank CLI with npm i @northflank/cli -g or yarn global add @northflank/cli. To log in, you will need to create an API token in your user or team account.

Available commands

forward           Port-forwarding for Northflank services and addons
login [options]   Connect the CLI to your Northflank account
context|contexts  Retrieve and update local context settings
list              List Northflank resources
create            Create Northflank resources
get               Get information about Northflank resources
delete            Delete Northflank resources
scale             Scale Northflank resources
update            Update Northflank resource properties
restart           Restart Northflank resources
pause             Pause Northflank resources
resume            Resume Northflank resources
help [command]    display help for command

Creating a service

To create a deployment service, use the create deploymentService command. You can also create other service types or projects:

project|projects [options]   Creates a new project.
combinedService [options]    Creates a new combined service.
deploymentService [options]  Creates a new deployment service.
buildService [options]       Creates a new build service.

Forwarding resources for local development

You can choose which services and addons to forward or select all project resources using the forward all command. This allows you to connect directly to your applications and databases without having to publically expose them.

Extended API

We have expanded the Northflank API so you can interact with your Northflank resources directly in your code. Documenation is available here.

const payload = {
  name: 'My awesome service',
  description: 'Example deployment service',
  billing: {
      deploymentPlan: 'micro'
  },
  deployment: {
    instances: 1,
    external: {
      registryProvider: 'dockerhub',
      imagePath: 'nginx:latest',
      privateImage: false,
    },
  },
  ports: [{ name: 'default-port', internalPort: 80, public: true, protocol: 'HTTP' }],
};
const response = await fetch(NORTHFLANK_API_ENDPOINT, {
  method: 'POST',
  headers: {
  	'Accept': 'application/json',
  	'Content-Type': 'application/json',
  	'Authorization': `Bearer ${NORTHFLANK_API_TOKEN}`,
},
  body: JSON.stringify(payload),
});
const { serviceType, serviceId } = await response.json()
console.log(`Deployed a service of type ${serviceType} with the ID ${serviceId}!`)
// => Deployed a service of type deployment with the ID my-awesome-service

Configurable health checks

You can now configure health checks on Northflank, with support for readiness and liveness probes. Health checks ensure zero-downtime deployments and automatic replacement of unhealthy instances.

Automatic port detection

Northflank fetches all ports exposed in a built Docker image automatically, or recursively from a Dockerfile added in your version control. We then configure your load-balancing automatically. This helps if you are unsure about the Dockerfile or if you don't know on which port(s) the application runs.

Networking security

Secure your services with IP Policies & Basic Authentication and configure them for one or multiple exposed ports in your deployment:

• Allow or block certain IP addresses or CIDR blocks
• Configure username and password combinations to restrict access to your endpoints
• Compose these security rules together to enable security in-depth, for example allowing access from a specific VPN and certain user credentials

Docker CMD override

We have added the ability to override the CMD of the Docker image in your deployment with a helpful interface giving you more observability over how your containers start.

Advanced job controls

We have added advanced job settings so you now control the number of retries, the concurrency policy and the maximum runtime duration.