To pay your Course Fee please follow this link

Building your First SF DevOps pipeline using Open Source Tools

Building your First SF DevOps pipeline using Open Source Tools
As we know, DevOps has now become the de facto answer to fixing the enterprise application development challenges like slow development, silos, and dysfunctional outputs. But, when it comes to SF DevOps project environment, the beginners are unsure of how to start with this. So, this article focuses on the concept of building a DevOps pipeline by keeping those newbies in mind. Even though this article is not comprehensive about all aspects of the same, it may help to give an overview for the users to start with it and explore more later.

Salesforce DevOps

The development of Salesforce involves the management and configuration of the metadata and releasing it. Compared to conventional software development approaches, this is slightly different as it involves only lesser among of code writing. Due to this diverse approach, Salesforce immensely helps the development projects with instant advantages like rapid feedback generation and quick resolution of the SDLC issues. SF DevOps environment for development will include the enterprise teams to instigate continuous feedback loops from the users and customers, which thereby helps to improve the overall quality of applications, IT responsiveness, and business agility.

Salesforce DevOps application development

Agile and lean development methodologies act as the nucleus of any DevOps project. These approaches will let any businesses to effectively develop and quickly deliver applications by using modern practices like Continuous Integration (CI), Continuous Delivery, and Continuous Deployment (CD). Here are the major benefits of SF DevOps approach.
  • Effective communication and collaboration
  • Faster feedback loops
  • Automation of the deployment pipeline
  • Frequent, ongoing releases, etc.
 

Building DevOps pipelines

Now, as we know the fundamentals of SF DevOps development environment and its advantages, let us come into our topic of discussion as building DevOps pipelines.

Step #1: Continuous Integration / Continuous Delivery framework

To start with making DevOps pipelines, you need some good CI/CD tools at the first point. The most popular choice is Jenkins, which is an open-source, Java-based tool coming under the MIT License. This is one tool that played a significant role in popularizing the DevOps development approach and has now become a default standard too in CI/CD. Jenkins functions like a magical remote which can interact with various other tools and services as an orchestrator of all. Jenkins is useless as a standalone CI/CD tool, but when it is combined with various tools to integrate them, Jenkins becomes the utmost powerful. Let us explore the other major CI/CD tools too as below.
  1. Travis CI
  2. Buildbot
  3. CruiseControl
  4. Cabie
  5. Apache Gump etc.
 

Step #2: Source Control Management

The easiest and the best possible way to verify the efficiency of your CI/CD tool is by integrating it with a good SCM (source control management) tool. If you are developing alone using any of the programming languages like Python, Java, Go, C++, Ruby, JavaScript, or anything else, things are easy. The source codes you write are put into the local directory. But, when the project is big, and other developers also collaborate in it, you should adopt a way to avoid any merge conflicts during code sharing and modifications. You should also have an effective way to recover an older version and roll back changes. This is the requirement met by source control management tools. An ideal SCM tool in SF DevOps enterprise development ecosystem will help you by sorting the codes in the repositories, versioning them, and coordinate among project members and teams at various locations. There are a lot of SCM tools available out there. However, Git is now adopted as a standard by many. Some other leading SCM tools are as below.
  • Subversion
  • Mercurial
  • Vesta
  • Concurrent Versions System (CVS) etc.
 

Step #3: Automation tools

Once you have arranged for source control, the next challenge in collaborative development is to compile and put the codes into the deployable package for execution. Some of the interpreted languages like PHP or JavaScript do not need compilation. You must choose a build automation tool for this purpose. No matter which one you choose, these automation tools share the same purpose. The objective is to build source code in the needed format and automate the process of cleaning, testing, compiling, and deploying it to the desired location. Build tools may differ based on the programming languages used, but there are some readily available open-source options as below. 
  • Maven under Apache 2.0 licensing – Java-based 
  • Bazel under Apache 2.0 license – Java-based
  • Gradle under Apache 2.0 license – Java-based 
  • Ant under Apache 2.0 license – Java-based
  • Make under GNU
  • Gulp under MIT – JavaScript-based
  • Grunt under MIT – JavaScript-based
  • Rake under MIT – Ruby based
  • SCons under MIT – Python-based
  • Cake under MIT – C# based
  • ASDF under Expat (MIT) – LISP based
  • Buildr under Apache – Ruby based
  • A-A-P under GNU – Python-based
  • BitBake under GPLv2 – Python-based
  • Cabal under BSD – Haskell based
You can effectively put the configuration files of the build automation tool into the SCM system and get it done by the CI/CD tools.

Step #4: Webserver

Once the above steps are completed, you may have the packaged file in hand, which is deployable. For any such application to function, it is essential to provide an interface or a third-party service and a vessel to host (hold) the application. In the case of web applications, a web server is a host. Application servers offer an ideal environment for the programming logic to deploy and render the interface to the users. In SF DevOps applications, you need to have an HTTP web server and an ideal environment like a virtual machine to install the server. Here are some open-source web app servers to consider. 
  • Tomcat: Apache 2.0: Java-based
  • Jetty: Apache  2.0: Java-based
  • Tornado: Apache 2.0: Python-based
  • Rails: MIT: Ruby-based
  • Node.js: MIT: JavaScript-based
  • Paste: MIT: Python-based
  • Gunicorn: MIT: Python-based
  • WildFly: GNU Lesser Public: Java-based
  • GlassFish: GNU Less Public: Java-based
  • Django 3-Clause: BSD: Python-based 
 

Step #5: Code testing

Code testing is another crucial requirement where the developers should catch bugs in the application at the earliest possible point to improve the code quality. There are many open-source tools for this purpose too, which can be plugged into the CI/CD tools for testing automation.
  • Junit: Eclipse Public License: Java-based
  • Mockito: MIT:  Java-based 
  • EasyMock: Apache: Java-based
  • Pytest: MIT: Python-based
  • PowerMock: Apache 2.0: Java-based
  • Tox: MIT: Python-based
  • Hypothesis: Mozilla: Python-based
Along with the above steps, you can also consider the options steps in building your DevOps pipelines as the usage of Containers like Docker and Kubernetes and also the use of middle automation tools like Ansible, SaltStack, Chef, Puppet etc.
Related Posts
Leave a Reply

Your email address will not be published.Required fields are marked *