Codefresh Platform by Octopus Deploy

Codefresh serves as the continuous integration tool in our GitOps principle deployment strategy, while we use Argo CD for deployment. Codefresh handles building, testing, and running test cases. When a change request is approved by the product team, developers push code that automatically triggers Codefresh for that specific branch. Codefresh checks out the code, runs unit and integration tests, then builds the Docker image.

A recent scenario where Codefresh failed involved one of our test cases. Codefresh properly failed the pipeline to ensure that code being pushed meets the highest quality standards and security gates. Other special gates are attached to the pipeline, such as SonarQube analysis. Codefresh ensures we are able to pass these fixes, and at the very least, it serves as our build tool.

The container-native pipeline and the handoff to Argo CD is quite unique.

The workflow I currently run has very specific use cases for strong Docker and Kubernetes integration, which is excellent. Codefresh is able to build, tag, scan, and push container images that fit naturally to our pipeline. It helps with the ease of GitOps integration. I really appreciate Codefresh because of the pipeline visualization. Not many tools have been able to deliver that feature in a way that interests me, where I can see where tests passed, where tests failed, security checks, and the image push. I value aesthetics in terms of UI, and Codefresh ticks that box for me in comparison to other tools.

The pipeline visualization, apart from the aesthetics, makes troubleshooting significantly easier because I have clear visibility on each stage. I know exactly what stage failed and I can troubleshoot in regards to those phases. For example, if a new version was not able to make it to our Kubernetes environment, instead of immediately troubleshooting the cluster, I can go into Codefresh and see the pipeline execution step by step. If the build and test had passed but the image push stage had failed, I can go back to the pipeline YAML file or the artifact files and precisely narrow down the problem. I do not have to troubleshoot from the Argo CD part. I know exactly where the pipeline has failed, so instead of second-guessing whether it is a security gate issue, a unit or integration test phase issue, or a Git leak phase issue, I know for certain that my image push has failed and I can troubleshoot from that very point.

Compared to other general-purpose CI tools such as Jenkins, what really stands out for me is how Codefresh fits into a containerized, Kubernetes-based workflow. With Jenkins, you can probably get the same pipeline, but you may spend more time managing plugins, agents, credentials, and other components. With Codefresh, the integration is seamless and fits very well with the GitOps model that we currently run, being able to automatically push and promote between environments. Codefresh comes in at a great place where I can hand off the build tool and not be worried about complexity and managing other tools. Being able to abstract complexity is huge, and Codefresh offers that scenario where I can abstract that extra level or extra layer of complexity.

Codefresh could be improved in the troubleshooting experience for more complex pipelines. When the pipelines are less complex, it is easier to troubleshoot. However, when we have bigger, longer, or more complex pipelines, although the visualization is useful, when we have multiple microservices, parallel stages, and GitOps updates, we can still end up going through quite a few logs to identify the actual root cause. I would like to see a stronger correlation across the entire workflow. We should be able to follow from the commit to the pipeline, through the container image and the GitOps update all the way to Argo CD. Improvements around pipeline debugging and clearer error messages would be beneficial.

There seems to be a disconnect between the CI part and trying to get across to the CD. If there can be improvements related to integrations in terms of making it easier to connect and move with the CD, that would be a very good development.

I have used Codefresh for two different projects, which spans around five years.

Codefresh is stable, 100%.

Scalability has been great so far. We have not had issues that we have had to consistently raise in terms of scalability with Codefresh availability or our builds. While we do not currently maintain the underlying physical infrastructure, I would say scalability has been excellent.

Customer service has been pretty good.

I switched because I changed teams. My current team uses Codefresh. My previous team used Jenkins, GitHub Actions, and GitLab CI.

Codefresh is a great tool that gets the job done. You do not have to worry about frequent outages, which we have not experienced much of. Escalation is quick and instant. I give this product a rating of seven out of ten.

My main use case for Codefresh is for build and release. For build and release with Codefresh, we maintain the version-controlled file of the pipeline. Once a commit happens, the build will trigger for that commit on that branch through a pull request. It will build the artifact, scan a few images in Docker, then put the artifact registry image in a remote registry, and then publish the deployed artifact to the deployed environment.

Codefresh is a very nice solution to have for build and release. It is similar to a Kubernetes and Docker instruction setup. There were many clusters we had from our different colleagues from different products that we used to maintain. I used to do user administration as well as team administration in there.

The best features Codefresh offers, in my experience, include user authentication, easy maintenance of YAMLs, and overall ease of use. It provides its own Kubernetes clusters out of the box in the given cloud. Codefresh has its own cloud platform and software as a solution.

The integration points with Slack and Teams help my workflow because they provide continuous notifications about whether the build has succeeded or not, allowing us to trial if it has failed for some reason. This keeps us moving forward. If a build passes, we get a notification in the channel, and then our team can start working on the next items from the backlog, and the ongoing sprint continues smoothly.

Codefresh has positively impacted my organization because many projects and products have come together under its umbrella. For example, one product has around thirty to forty APIs, and we have seven to eight products now in that company. They are doing really great with Codefresh.

Codefresh has helped save time, reduce errors, and improve collaboration across teams. The integration points help us to reduce time, improve performance, and make collaboration between teams easier to follow. We can have our coffee breaks, tea breaks, and lunch breaks and relax because Codefresh is looking after the things going on.

The challenge that we faced with Codefresh is that it is a complex setup. Kubernetes and Docker are somewhat complex. However, the cluster needs many computer resources to have Kubernetes and Docker running in the pipelines. Additionally, some design decisions made us move away from Codefresh to another vendor for pipelines. When we had Codefresh, it was a very nice solution to have, but partly, we have moved to another vendor for pipelines.

The improvements needed for Codefresh include making it easier to create the clusters. Also, navigating to Docker-within-Docker and Docker-within-Kubernetes needs to be easy and well-documented. It is a very nice tool, but management has decided to save on some costs and follow the process.

I have been using Codefresh for about a year.

In my experience, Codefresh is stable with not many challenges in hiccups or in clusters, but it is somewhat complex.

Codefresh has handled growth and increased workloads quite well.

The customer support for Codefresh has been nice. One of the team members had a few configurations that we suggested to Codefresh, and they took it and applied those configurations within Codefresh's product.

Before Codefresh, we used to use STAR Team. The reason for the change was to simplify the workflow since we needed to maintain two integration points in STAR Team, whereas Codefresh simplifies the workflow.

From my position, I have not seen a return on investment with Codefresh.

I was not involved much in the pricing, but Codefresh is nice because we used to share the licensing, cluster creation, and those accounts around products. If one product needs a certain amount of compute and memory, that compute and memory is provided to that product team from other team members. It is nice to have that. We used to predefine that we needed sixteen GB of RAM, thirty-two GB of RAM, eighty GB of space, and compute, and share that with our team for smoke testing, load testing, and stress testing for the QA teams.

The advice I would give to others looking into using Codefresh is that they need to have that budget. Whoever wants to use Codefresh needs to have the budget and a return on investment. They need to have money from the client or vendors so that they can invest in Codefresh. Otherwise, it is a nice solution if the money is there. Somebody can log into Codefresh and do the project things. I would rate my overall experience with Codefresh a seven out of ten.

My main use case for Codefresh is building pipelines, changing config, and creating a platform for developers.

When I use Codefresh for building pipelines or creating that developer platform, I use a template that we bootstrapped for everyone else in the bank. We started building our own dedicated pipelines using this template. It would be in our GKE, as a shared pipeline in a shared cluster that we would use to deploy our GKE resources.

In my opinion, the best features Codefresh offers are extensibility, flexibility, a lot of features, and it is also very fast. The documentation is really good and helps me in my day-to-day work. We were able to quickly move off Bamboo and CodeBuild from Google Cloud while using the same functionality that we require. Codefresh has really good GitOps capabilities.

Codefresh has positively impacted my organization; it has been amazing. Previously, we would have to build scripts and go into Cloud Build in GCP, and we would have to build our own Terraform images and run that inside Cloud Build. When Codefresh came along, it was much easier to share code with everyone else because we had a single pipeline and similar templates.

Everyone was more on board since switching to Codefresh. In terms of time saved, I would say one day saved per week. We used to have a lot of toil with Cloud Build, but no more with Codefresh.

Codefresh can be improved with more capability inside the GCP ecosystem. The initial setup felt very manual.

I have been using Codefresh for four years.

Codefresh is very stable.

Codefresh's scalability is 10 out of 10; it is very scalable. We have never hit an issue.

I have never had to deal with customer support.

I previously used Bamboo and Cloud Build. Everyone used different tools, so that is why they wanted to align when we switched to Codefresh.

We did not purchase Codefresh through the Google Cloud Marketplace; we had an enterprise license.

I did not know about the experience with pricing, setup cost, and licensing as they have one procurement team, and engineers do not have to do this.

I evaluated other options before choosing Codefresh. We did not like Bamboo as it was being deprecated, so we used Cloud Build.

My advice for others looking into using Codefresh is to have a templated repo and have people start off with that. I would rate this product 10 out of 10.