Alternatives to Terraform logo

Alternatives to Terraform

Ansible, Kubernetes, Packer, Cloud Foundry, and Pulumi are the most popular alternatives and competitors to Terraform.
18.4K
14.5K
+ 1
344

What is Terraform and what are its top alternatives?

Terraform is an open-source infrastructure as code software tool created by HashiCorp that allows users to define and provision data center infrastructure using a declarative configuration language. Its key features include infrastructure as code, multi-cloud support, state management, and plan functionality. However, some limitations of Terraform include a steep learning curve for beginners and potential complexity in managing state files.

  1. Pulumi: Pulumi is an open-source infrastructure as code tool that allows users to write infrastructure code in familiar programming languages like Python, JavaScript, and Go. It offers features like infrastructure as code, multi-cloud support, and real programming languages for configuration management. Pros include the ability to use familiar programming languages, while cons may include less community support compared to Terraform.
  2. Ansible: Ansible is an open-source automation tool that focuses on configuration management and application deployment. It offers features like agentless architecture, easy configuration management, and broad community support. Pros include simplicity and ease of use, while cons may include limited support for cloud provisioning compared to Terraform.
  3. AWS CloudFormation: AWS CloudFormation is a service provided by Amazon Web Services for infrastructure as code. It offers features like automated provisioning, template-based infrastructure setup, and native integration with AWS services. Pros include seamless integration with AWS services, while cons may include limited support for multi-cloud environments.
  4. Google Cloud Deployment Manager: Google Cloud Deployment Manager is a service provided by Google Cloud Platform for infrastructure as code. It offers features like declarative configuration, templates for resource management, and integration with Google Cloud services. Pros include tight integration with Google Cloud services, while cons may include limited support for other cloud providers.
  5. Azure Resource Manager: Azure Resource Manager is a service provided by Microsoft Azure for infrastructure as code. It offers features like template-based deployment, resource group management, and integration with Azure services. Pros include seamless integration with Azure services, while cons may include limited support for multi-cloud environments.
  6. Chef Infrastructure Management: Chef Infrastructure Management is a tool that focuses on automation and configuration management. It offers features like agent-based automation, policy-driven infrastructure management, and support for hybrid environments. Pros include powerful automation capabilities, while cons may include a steeper learning curve and less focus on multi-cloud support.
  7. SaltStack: SaltStack is an open-source automation tool that emphasizes event-driven infrastructure management. It offers features like remote execution, configuration management, and scalability for large environments. Pros include robust automation capabilities, while cons may include a more complex setup compared to Terraform.
  8. Juju: Juju is an open-source service orchestration tool that focuses on managing applications and services on cloud infrastructure. It offers features like model-driven operations, easy service deployment, and support for various cloud providers. Pros include simplicity in service management, while cons may include a narrower focus compared to Terraform's broader infrastructure management capabilities.
  9. Cloudify: Cloudify is an open-source orchestration platform that emphasizes multi-cloud management and automation. It offers features like model-driven orchestration, support for hybrid environments, and integration with various cloud providers. Pros include strong multi-cloud capabilities, while cons may include a potentially steeper learning curve compared to Terraform.
  10. OpenStack Heat: OpenStack Heat is an orchestration service within the OpenStack cloud platform that enables users to define and manage resources using templates. It offers features like template-based provisioning, integration with OpenStack services, and scalability for large deployments. Pros include tight integration with OpenStack infrastructure, while cons may include limited support for non-OpenStack environments.

Top Alternatives to Terraform

  • Ansible
    Ansible

    Ansible is an IT automation tool. It can configure systems, deploy software, and orchestrate more advanced IT tasks such as continuous deployments or zero downtime rolling updates. Ansible’s goals are foremost those of simplicity and maximum ease of use. ...

  • Kubernetes
    Kubernetes

    Kubernetes is an open source orchestration system for Docker containers. It handles scheduling onto nodes in a compute cluster and actively manages workloads to ensure that their state matches the users declared intentions. ...

  • Packer
    Packer

    Packer automates the creation of any type of machine image. It embraces modern configuration management by encouraging you to use automated scripts to install and configure the software within your Packer-made images. ...

  • Cloud Foundry
    Cloud Foundry

    Cloud Foundry is an open platform as a service (PaaS) that provides a choice of clouds, developer frameworks, and application services. Cloud Foundry makes it faster and easier to build, test, deploy, and scale applications. ...

  • Pulumi
    Pulumi

    Pulumi is a cloud development platform that makes creating cloud programs easy and productive. Skip the YAML and just write code. Pulumi is multi-language, multi-cloud and fully extensible in both its engine and ecosystem of packages. ...

  • Chef
    Chef

    Chef enables you to manage and scale cloud infrastructure with no downtime or interruptions. Freely move applications and configurations from one cloud to another. Chef is integrated with all major cloud providers including Amazon EC2, VMWare, IBM Smartcloud, Rackspace, OpenStack, Windows Azure, HP Cloud, Google Compute Engine, Joyent Cloud and others. ...

  • Jenkins
    Jenkins

    In a nutshell Jenkins CI is the leading open-source continuous integration server. Built with Java, it provides over 300 plugins to support building and testing virtually any project. ...

  • Serverless
    Serverless

    Build applications comprised of microservices that run in response to events, auto-scale for you, and only charge you when they run. This lowers the total cost of maintaining your apps, enabling you to build more logic, faster. The Framework uses new event-driven compute services, like AWS Lambda, Google CloudFunctions, and more. ...

Terraform alternatives & related posts

Ansible logo

Ansible

19.1K
1.3K
Radically simple configuration-management, application deployment, task-execution, and multi-node orchestration engine
19.1K
1.3K
PROS OF ANSIBLE
  • 284
    Agentless
  • 210
    Great configuration
  • 199
    Simple
  • 176
    Powerful
  • 155
    Easy to learn
  • 69
    Flexible
  • 55
    Doesn't get in the way of getting s--- done
  • 35
    Makes sense
  • 30
    Super efficient and flexible
  • 27
    Powerful
  • 11
    Dynamic Inventory
  • 9
    Backed by Red Hat
  • 7
    Works with AWS
  • 6
    Cloud Oriented
  • 6
    Easy to maintain
  • 4
    Vagrant provisioner
  • 4
    Simple and powerful
  • 4
    Multi language
  • 4
    Simple
  • 4
    Because SSH
  • 4
    Procedural or declarative, or both
  • 4
    Easy
  • 3
    Consistency
  • 2
    Well-documented
  • 2
    Masterless
  • 2
    Debugging is simple
  • 2
    Merge hash to get final configuration similar to hiera
  • 2
    Fast as hell
  • 1
    Manage any OS
  • 1
    Work on windows, but difficult to manage
  • 1
    Certified Content
CONS OF ANSIBLE
  • 8
    Dangerous
  • 5
    Hard to install
  • 3
    Doesn't Run on Windows
  • 3
    Bloated
  • 3
    Backward compatibility
  • 2
    No immutable infrastructure

related Ansible posts

Tymoteusz Paul
Devops guy at X20X Development LTD · | 23 upvotes · 10M views

Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

See more
Sebastian Gębski

Heroku was a decent choice to start a business, but at some point our platform was too big, too complex & too heterogenic, so Heroku started to be a constraint, not a benefit. First, we've started containerizing our apps with Docker to eliminate "works in my machine" syndrome & uniformize the environment setup. The first orchestration was composed with Docker Compose , but at some point it made sense to move it to Kubernetes. Fortunately, we've made a very good technical decision when starting our work with containers - all the container configuration & provisions HAD (since the beginning) to be done in code (Infrastructure as Code) - we've used Terraform & Ansible for that (correspondingly). This general trend of containerisation was accompanied by another, parallel & equally big project: migrating environments from Heroku to AWS: using Amazon EC2 , Amazon EKS, Amazon S3 & Amazon RDS.

See more
Kubernetes logo

Kubernetes

59.9K
681
Manage a cluster of Linux containers as a single system to accelerate Dev and simplify Ops
59.9K
681
PROS OF KUBERNETES
  • 166
    Leading docker container management solution
  • 129
    Simple and powerful
  • 107
    Open source
  • 76
    Backed by google
  • 58
    The right abstractions
  • 25
    Scale services
  • 20
    Replication controller
  • 11
    Permission managment
  • 9
    Supports autoscaling
  • 8
    Simple
  • 8
    Cheap
  • 6
    Self-healing
  • 5
    Open, powerful, stable
  • 5
    Reliable
  • 5
    No cloud platform lock-in
  • 5
    Promotes modern/good infrascture practice
  • 4
    Scalable
  • 4
    Quick cloud setup
  • 3
    Custom and extensibility
  • 3
    Captain of Container Ship
  • 3
    Cloud Agnostic
  • 3
    Backed by Red Hat
  • 3
    Runs on azure
  • 3
    A self healing environment with rich metadata
  • 2
    Everything of CaaS
  • 2
    Gke
  • 2
    Golang
  • 2
    Easy setup
  • 2
    Expandable
  • 2
    Sfg
CONS OF KUBERNETES
  • 16
    Steep learning curve
  • 15
    Poor workflow for development
  • 8
    Orchestrates only infrastructure
  • 4
    High resource requirements for on-prem clusters
  • 2
    Too heavy for simple systems
  • 1
    Additional vendor lock-in (Docker)
  • 1
    More moving parts to secure
  • 1
    Additional Technology Overhead

related Kubernetes posts

Conor Myhrvold
Tech Brand Mgr, Office of CTO at Uber · | 44 upvotes · 12.7M views

How Uber developed the open source, end-to-end distributed tracing Jaeger , now a CNCF project:

Distributed tracing is quickly becoming a must-have component in the tools that organizations use to monitor their complex, microservice-based architectures. At Uber, our open source distributed tracing system Jaeger saw large-scale internal adoption throughout 2016, integrated into hundreds of microservices and now recording thousands of traces every second.

Here is the story of how we got here, from investigating off-the-shelf solutions like Zipkin, to why we switched from pull to push architecture, and how distributed tracing will continue to evolve:

https://eng.uber.com/distributed-tracing/

(GitHub Pages : https://www.jaegertracing.io/, GitHub: https://github.com/jaegertracing/jaeger)

Bindings/Operator: Python Java Node.js Go C++ Kubernetes JavaScript OpenShift C# Apache Spark

See more
Yshay Yaacobi

Our first experience with .NET core was when we developed our OSS feature management platform - Tweek (https://github.com/soluto/tweek). We wanted to create a solution that is able to run anywhere (super important for OSS), has excellent performance characteristics and can fit in a multi-container architecture. We decided to implement our rule engine processor in F# , our main service was implemented in C# and other components were built using JavaScript / TypeScript and Go.

Visual Studio Code worked really well for us as well, it worked well with all our polyglot services and the .Net core integration had great cross-platform developer experience (to be fair, F# was a bit trickier) - actually, each of our team members used a different OS (Ubuntu, macos, windows). Our production deployment ran for a time on Docker Swarm until we've decided to adopt Kubernetes with almost seamless migration process.

After our positive experience of running .Net core workloads in containers and developing Tweek's .Net services on non-windows machines, C# had gained back some of its popularity (originally lost to Node.js), and other teams have been using it for developing microservices, k8s sidecars (like https://github.com/Soluto/airbag), cli tools, serverless functions and other projects...

See more
Packer logo

Packer

582
42
Create identical machine images for multiple platforms from a single source configuration
582
42
PROS OF PACKER
  • 27
    Cross platform builds
  • 9
    Vm creation automation
  • 4
    Bake in security
  • 1
    Good documentation
  • 1
    Easy to use
CONS OF PACKER
    Be the first to leave a con

    related Packer posts

    John Kodumal

    LaunchDarkly is almost a five year old company, and our methodology for deploying was state of the art... for 2014. We recently undertook a project to modernize the way we #deploy our software, moving from Ansible-based deploy scripts that executed on our local machines, to using Spinnaker (along with Terraform and Packer) as the basis of our deployment system. We've been using Armory's enterprise Spinnaker offering to make this project a reality.

    See more
    Cloud Foundry logo

    Cloud Foundry

    188
    5
    Deploy and scale applications in seconds on your choice of private or public cloud
    188
    5
    PROS OF CLOUD FOUNDRY
    • 2
      Perfectly aligned with springboot
    • 1
      Free distributed tracing (zipkin)
    • 1
      Application health management
    • 1
      Free service discovery (Eureka)
    CONS OF CLOUD FOUNDRY
      Be the first to leave a con

      related Cloud Foundry posts

      Pulumi logo

      Pulumi

      262
      25
      Modern Infrastructure as Code
      262
      25
      PROS OF PULUMI
      • 8
        Infrastructure as code with less pain
      • 4
        Best-in-class kubernetes support
      • 3
        Simple
      • 3
        Can use many languages
      • 2
        Great CLI
      • 2
        Can be self-hosted
      • 2
        Multi-cloud
      • 1
        Built-in secret management
      CONS OF PULUMI
        Be the first to leave a con

        related Pulumi posts

        Chef logo

        Chef

        1.3K
        345
        Build, destroy and rebuild servers on any public or private cloud
        1.3K
        345
        PROS OF CHEF
        • 110
          Dynamic and idempotent server configuration
        • 76
          Reusable components
        • 47
          Integration testing with Vagrant
        • 43
          Repeatable
        • 30
          Mock testing with Chefspec
        • 14
          Ruby
        • 8
          Can package cookbooks to guarantee repeatability
        • 7
          Works with AWS
        • 3
          Has marketplace where you get readymade cookbooks
        • 3
          Matured product with good community support
        • 2
          Less declarative more procedural
        • 2
          Open source configuration mgmt made easy(ish)
        CONS OF CHEF
          Be the first to leave a con

          related Chef posts

          In late 2013, the Operations Engineering team at PagerDuty was made up of 4 engineers, and was comprised of generalists, each of whom had one or two areas of depth. Although the Operations Team ran its own on-call, each engineering team at PagerDuty also participated on the pager.

          The Operations Engineering Team owned 150+ servers spanning multiple cloud providers, and used Chef to automate their infrastructure across the various cloud providers with a mix of completely custom cookbooks and customized community cookbooks.

          Custom cookbooks were managed by Berkshelf, andach custom cookbook contained its own tests based on ChefSpec 3, coupled with Rspec.

          Jenkins was used to GitHub for new changes and to handle unit testing of those features.

          See more
          Marcel Kornegoor

          Since #ATComputing is a vendor independent Linux and open source specialist, we do not have a favorite Linux distribution. We mainly use Ubuntu , Centos Debian , Red Hat Enterprise Linux and Fedora during our daily work. These are also the distributions we see most often used in our customers environments.

          For our #ci/cd training, we use an open source pipeline that is build around Visual Studio Code , Jenkins , VirtualBox , GitHub , Docker Kubernetes and Google Compute Engine.

          For #ServerConfigurationAndAutomation, we have embraced and contributed to Ansible mainly because it is not only flexible and powerful, but also straightforward and easier to learn than some other (open source) solutions. On the other hand: we are not affraid of Puppet Labs and Chef either.

          Currently, our most popular #programming #Language course is Python . The reason Python is so popular has to do with it's versatility, but also with its low complexity. This helps sysadmins to write scripts or simple programs to make their job less repetitive and automating things more fun. Python is also widely used to communicate with (REST) API's and for data analysis.

          See more
          Jenkins logo

          Jenkins

          58.4K
          2.2K
          An extendable open source continuous integration server
          58.4K
          2.2K
          PROS OF JENKINS
          • 523
            Hosted internally
          • 469
            Free open source
          • 318
            Great to build, deploy or launch anything async
          • 243
            Tons of integrations
          • 211
            Rich set of plugins with good documentation
          • 111
            Has support for build pipelines
          • 68
            Easy setup
          • 66
            It is open-source
          • 53
            Workflow plugin
          • 13
            Configuration as code
          • 12
            Very powerful tool
          • 11
            Many Plugins
          • 10
            Continuous Integration
          • 10
            Great flexibility
          • 9
            Git and Maven integration is better
          • 8
            100% free and open source
          • 7
            Github integration
          • 7
            Slack Integration (plugin)
          • 6
            Easy customisation
          • 6
            Self-hosted GitLab Integration (plugin)
          • 5
            Docker support
          • 5
            Pipeline API
          • 4
            Fast builds
          • 4
            Platform idnependency
          • 4
            Hosted Externally
          • 4
            Excellent docker integration
          • 3
            It`w worked
          • 3
            Customizable
          • 3
            Can be run as a Docker container
          • 3
            It's Everywhere
          • 3
            JOBDSL
          • 3
            AWS Integration
          • 2
            Easily extendable with seamless integration
          • 2
            PHP Support
          • 2
            Build PR Branch Only
          • 2
            NodeJS Support
          • 2
            Ruby/Rails Support
          • 2
            Universal controller
          • 2
            Loose Coupling
          CONS OF JENKINS
          • 13
            Workarounds needed for basic requirements
          • 10
            Groovy with cumbersome syntax
          • 8
            Plugins compatibility issues
          • 7
            Lack of support
          • 7
            Limited abilities with declarative pipelines
          • 5
            No YAML syntax
          • 4
            Too tied to plugins versions

          related Jenkins posts

          Tymoteusz Paul
          Devops guy at X20X Development LTD · | 23 upvotes · 10M views

          Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

          It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

          I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

          We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

          If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

          The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

          Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

          See more
          Thierry Schellenbach

          Releasing new versions of our services is done by Travis CI. Travis first runs our test suite. Once it passes, it publishes a new release binary to GitHub.

          Common tasks such as installing dependencies for the Go project, or building a binary are automated using plain old Makefiles. (We know, crazy old school, right?) Our binaries are compressed using UPX.

          Travis has come a long way over the past years. I used to prefer Jenkins in some cases since it was easier to debug broken builds. With the addition of the aptly named “debug build” button, Travis is now the clear winner. It’s easy to use and free for open source, with no need to maintain anything.

          #ContinuousIntegration #CodeCollaborationVersionControl

          See more
          Serverless logo

          Serverless

          1.3K
          26
          The most widely-adopted toolkit for building serverless applications
          1.3K
          26
          PROS OF SERVERLESS
          • 14
            API integration
          • 7
            Supports cloud functions for Google, Azure, and IBM
          • 3
            Lower cost
          • 1
            Auto scale
          • 1
            Openwhisk
          CONS OF SERVERLESS
            Be the first to leave a con

            related Serverless posts

            Praveen Mooli
            Engineering Manager at Taylor and Francis · | 19 upvotes · 4M views

            We are in the process of building a modern content platform to deliver our content through various channels. We decided to go with Microservices architecture as we wanted scale. Microservice architecture style is an approach to developing an application as a suite of small independently deployable services built around specific business capabilities. You can gain modularity, extensive parallelism and cost-effective scaling by deploying services across many distributed servers. Microservices modularity facilitates independent updates/deployments, and helps to avoid single point of failure, which can help prevent large-scale outages. We also decided to use Event Driven Architecture pattern which is a popular distributed asynchronous architecture pattern used to produce highly scalable applications. The event-driven architecture is made up of highly decoupled, single-purpose event processing components that asynchronously receive and process events.

            To build our #Backend capabilities we decided to use the following: 1. #Microservices - Java with Spring Boot , Node.js with ExpressJS and Python with Flask 2. #Eventsourcingframework - Amazon Kinesis , Amazon Kinesis Firehose , Amazon SNS , Amazon SQS, AWS Lambda 3. #Data - Amazon RDS , Amazon DynamoDB , Amazon S3 , MongoDB Atlas

            To build #Webapps we decided to use Angular 2 with RxJS

            #Devops - GitHub , Travis CI , Terraform , Docker , Serverless

            See more
            Nitzan Shapira

            At Epsagon, we use hundreds of AWS Lambda functions, most of them are written in Python, and the Serverless Framework to pack and deploy them. One of the issues we've encountered is the difficulty to package external libraries into the Lambda environment using the Serverless Framework. This limitation is probably by design since the external code your Lambda needs can be usually included with a package manager.

            In order to overcome this issue, we've developed a tool, which we also published as open-source (see link below), which automatically packs these libraries using a simple npm package and a YAML configuration file. Support for Node.js, Go, and Java will be available soon.

            The GitHub respoitory: https://github.com/epsagon/serverless-package-external

            See more