We now have Starter Projects for Django, Flask, Nest, and Nuxt! What should we build next?

Previews, production, and everything in between

Democratize deployments and environment creation with our dependency-aware continuous delivery platform


Let us automate that

DevOps is the intersection of several tools and processes. All of which can be automated with Architect.

APPLICATION DELIVERY

Developers waste hours of time writing tedious pipelining scripts and babysitting deployments. Help your developers focus on your product.

NETWORK SECURITY

Network security is critical to protecting your customers and business, but instrumentation is tedious and error prone.

ENVIRONMENT PROVISIONING

Developers need to run and test their applications in private sandboxes and preview environments, but DevOps engineers never have time to support temporary environments.


DevOps starts with Developers

Our cloud platform and Architecture-as-Code framework are everything developers need to build and ship new apps and services to production-grade environments.

Declarative config files

Define your apps, services, and architecture using a declarative configuration file so that your stack can be run anywhere, by anyone, for any reason.

# Describe services, cronjobs, and more in a declarative
# format as simple as docker-compose
services:
  auth:
    build:
      context: ./auth-service
    interfaces:
      rest:
        port: 8080
    environment:
      LOG_LEVEL: info

  api:
    build:
      context: ./api-service
    interfaces:
      rest:
        port: 8081

Intuitive service discovery

Different environments use different hostnames and tools for service discovery, load balancing, and security. Don’t let that slow down development and let Architect configure it for you.

services:
  auth:
    build:
      context: ./auth-service
    interfaces:
      rest:
        port: 8080
    environment:
      LOG_LEVEL: info

  api:
    build:
      context: ./api-service
    interfaces:
      rest:
        port: 8081
    environment:
      # Populate peer addresses by reference. Architect will
      # automatically instrument service discovery and strict
      # network policies with each deployment
      AUTH_URL: ${{ services.auth.interfaces.rest.url }}

External dependency injection

Your app is distributed, and so is the knowledge of its architecture. Leverage familiar dependency management practices to connect to databases, message queues, peer APIs, and other external dependencies.

# Claim dependencies that will be automatically provisioned
# as-needed to power your own services
dependencies:
  postgres/postgres: 13
  company/auth: 1.2.0

services:
  api:
    build:
      context: ./api-service
    interfaces:
      rest:
        port: 8081
    environment:
      # Automatically connect to APIs exposed by dependencies w/out
      # getting lost in the details
      DB_URL: ${{ dependencies['company/auth'].interfaces.db.url }}
      AUTH_URL: ${{ dependencies['company/auth'].interfaces.app.url }}

Private developer environments

Running and testing features and services is critical for developer productivity. Architect’s automation isn’t just for production environments, but for private developer environments as well.

# Single command to stand up private dev environment
$ architect dev ./architect.yml

# ...streaming docker compose logs...
Wrote docker-compose file to: ~/.config/architect/docker-compose/architect.yml
[+] Building 0.9s (11/12)
 => [architect_cloud-api-worker-a8ucsqbe internal] load build definition from Dockerfile                                          0.0s
[+] Building 3.9s (12/21)
 => [architect_cloud-api-worker-a8ucsqbe internal] load build definition from Dockerfile                                          0.0s
 => => transferring dockerfile: 671B                                                                                              0.0s
 => [architect_cloud-app-1ywfwdkp internal] load build definition from Dockerfile                                                 0.0s
 => => transferring dockerfile: 1.04kB                                                                                            0.0s
 => [architect_auth-app-frykeeda internal] load build definition from Dockerfile                                                  0.0s
 => => transferring dockerfile: 210B                                                                                              0.0s
 => [architect_cloud-registry-proxy-phkgeuwd internal] load build definition from Dockerfile                                      0.0s
 => => transferring dockerfile: 481B                                                                                              0.0s
# ...

Preview environments

The earlier a feature can be tested in a production-like environment, the faster the changes can be trusted and released. Architect’s automation enables full environments to be provisioned and destroyed with each pull request.

# GitHub actions workflow template
name: Architect Create Preview

# Triggers on every pull request
on:
  pull_request:
    branches:
      - master

jobs:
  create_preview:
    runs-on: ubuntu-latest
    steps:
      # ...
      - run: sudo npm install -g @architect-io/cli
      - run: architect login -e me@domain.com -p mysecurepassword
      - run: architect register ./architect.yml -t preview-${{ github.event.number }}
      - run: architect environment:create preview-${{ github.event.number }} -a architect-account --platform preview-platform || exit 0
      - run: architect deploy --auto_approve -a architect-account -e preview-${{ github.event.number }} architect-account/my-component:preview-${{ github.event.number }}

Self-service deployments

Consistency is the key to successful deployments. Deploying with Architect is the same for every service and every environment, making production deployments safe and reliable for every developer on your team.

Marquee screenshot

Distributed apps, centralized governance

Our cloud platform gives you visibility, protection, and compliance without sacrificing productivity.

Application &
service catalog

View your full portfolio of apps and services, and share it with your team to ensure that no one is re-inventing the wheel.

Cluster management
& access control

Architect helps teams create, manage, and distribute access to the clusters that will play host to production and developer environments alike.

Centralized
governance

Visualize and assign policies for all of your production and non-production environments with Architect Cloud. Deployments will automatically inject policies and settings without impacting developer productivity.

Zero trust
cloud security

Architect’s deploy process includes the unique ability to enrich deployments with strict network policies, ensuring that environments are as secure as possible at all times.

Compliance &
audit trails

Every deployment comes complete with a detailed breakdown of the changes applied, how long the deployment took, and who triggered the deployment – all the information needed to maintain compliance and protect your business.


Tried, Tested, Trusted.

Architect is used by the best in the business from development to production