Skip to content

Frequently Asked Questions

How do I get started?

You need a:

  • Github OR Bitbucket  Account
  • AWS IAM  Credentials.

Onboarding

  • takes about 5 minutes
  • your first project takes 2-3 minutes.

How are platforms built and distributed?

Self-service platforms are built through glue-ing technologies into connected pipelines (workflows).  Pipelines (workflows) occur as one time or triggered, recurring automation. For example, pipelines (workflows) can be categorized as:

  • One time A to B automation. An example of A to B one time automation is managing AWS, where resources are created once like a database and EKS cluster.  The automation is executed once.
  • Recurring or triggered automation. An example of triggered automation is data pipelines such as a conventional ETL that extracts, transforms, and loads data from a data stream to a data analytics platform like RedShift.  Another form of triggered automation is CI/CD, where the automation is executed frequently through code changes.

The automation takes place at:

  • The orchestration layer automation typically involves non-server configuration activities such as making API calls to cloud providers AWS, Azure, and Google Compute.  Jenkins and Stackstorm are tools that fall into this category.
  • The delegation layer (configuration management) involves modifying and configuring a server.  Chef and Ansible are tools that fall into this category.

ElasticDev sequentializes activities on both the orchestration and delegation layer. If you have existing investments in tools like Ansible and Terraform, there is no need to abandon them. They can be easily glued into stacks to provide a single parameterized point of entry.

How is ElasticDev different?

ElasticDev’s approach emphasizes transparency, visibility, and security. Most automation products begin with a hierarchy by coding a solution. When that product needs to be extended or modified, modifications can be challenging. For example, CI/CD products that are extended to perform cloud automation (e.g. AWS, Azure) are limited.  Tasks such as creating a MongoDb database, loading the schema to it, and configuring indexes and TTLs are less than straight forward.

ED does not begin with the hierarchy.  Our approach is similar to stem cells. We do not begin with an eye cell and then try to make it an ear cell. Rather, we begin with stem cells.  Low level components are glued into stacks, which ultimately determine the hierarchy.  For example, our Terraform and Ansible getting started guide outlines the ED’s conventions for the integration.   However,  users are free to implement their own implementation and conventions for integrating these products.  We love to people provide better integration approaches, driven by users and endorsed by the community.

Can stacks be protected?

Yes, stacks are public or private.  Private stacks are only seen by the owners, while public stacks are shared and seen by others in the ED Marketplace.

Why is the different between stacks and elasticdev.yml?

Stacks contain the logic for the automation.  You can call other stacks within a stack.  Stacks are versioned and locked.  In contrast, the elasticdev.yml locks not only the stacks themselves, but also the variables and arguments the determine the behavior of the stack(s).  In other words, it locks the “launch” of automation: variables + stacks.

Can you do function as a service (serverless)?

Yes, ED is technology agnostic.  There is an example of an AWS lambda function in the ED Marketplace using Serverless.

How is this different than AgileStacks/Pivotal Labs/Openshift?

These PaaS systems are opinionated, and designed for customers that effectively outsource DevOps for the platform and support.

Pivotal Labs and Agilestacks are designed primarily for web applications, expensive, and provide a only handful of solutions.  Openshift is centered exclusively around Kubernetes and not meant to be used for other technologies like Ansible, Terraform, or Serverless.

In contrast, ED is both flexible and opinionated.  Since glue-ing technologies involves the layering of stacks, users have different entry points to enter and customize automation.  Users control what technologies they use and how they use it.

How is this different than CircleCI/TravisCI/Codefresh/BuildKite?

ElasticDev is not a Continuation Integration (CI) platform. CI is a specific type of automation.  ED treats CI like any other automation and allow users to select their preferred CI implementation. Through stacks, users can also build their own CI implementation.

Currently, the marketplace contains two CI stacks.

Below is a summary of the variety of CI stacks, which automatically creates the needed ec2 resources in your account - share nothing.

  • ec2_ci
    • A fully operational Docker CI system on AWS/ec2, which tests and builds a single microservice on a single Docker build host.
    • Stops an instance when not in use to save costs.
    • Pros - cost savings
    • Cons - slower
  • ec2_ci_fastest
    • A fully operational Docker CI system on AWS/ec2, which tests and builds a single microservice on a single Docker build host.
    • It is as fast or faster than building on one’s laptop, taking full advantage of hot Docker cache.
    • We challenge you to find a faster CI system.
    • Pros - fastest
    • Cons - less cost savings

Can you run a traditional application?

Definitely. For those who run a monolithic application, our platform can handle automation such AMI creation, autoscaling, and ELB/ALB configuration.

Are stacks easy to create?

Like Docker files, stacks are simple to read and write.  They are written in python and are launched through yaml configs.  An example of a yaml config is shown below.

global_arguments:
   aws_default_region: us-east-1
   docker_repo: flask_sample
infrastructure:
   ecr_repo:
       stack_name: elasticdev:::ecr_repo
       arguments:
          name: flask_sample
   dockerhost:
       stack_name: elasticdev:::ec2_docker_host
       arguments:
          size: t2.micro
          disksize: 25
       stack_vars:
           - name: elasticdev:::ubuntu::ec2_ubuntu
             arguments:
                  ip_key: public_ip
build:
   ci_example:
       create_webhook: False
       dependencies: 
           - infrastructure::dockerhost
           - infrastructure::ecr_repo
       stack_name: elasticdev:::ec2_ci_fastest
       arguments:
           repo_url: https://bitbucket.org/williaumwu/flask_sample
           repo_branch: dev
           dockerfile: Dockerfile
           dockerfile_test: Dockerfile_test
           triggered_branches:
             - dev