Sonatype Lifecycle

Sonatype Lifecycle is basically a central use case for scanning applications in the CI/CD for vulnerabilities or non-compliant open-source dependencies and enforces policy across the dev lifecycle. It is reactive, continuous monitoring of what's already in your application. This is the benefit of it.

The benefits or features that I appreciate about Sonatype Lifecycle are that it is reactive and it supports CI/CD. There is early detection, so it will flag the vulnerabilities in the open-source dependencies straight away. Also, if you have the policies, it will automate the enforcement for you. If you have severity thresholds or you define something, it enforces them automatically in the CI/CD builds.

There is also the remediation guidance. It will give you the best version to upgrade to. It will not just flag that there is a CVE, but it will also give you recommendations on what version you need to fix to. Continuous monitoring is another benefit.

The reporting, audit and reporting is also valuable. In the dashboard, you will see the application risks reports, and security teams will look at and see what's happening with certain applications. In a nutshell, it enables faster releases and lower security exposure.

If we add Sonatype Lifecycle for Azure, it works for pipelines, and it allows you to run pipelines in the environment. You will have CI/CD, continuous integration, continuous development. People will have faster results. Instead of having DevOps, we have DevSecOps because of this. It improves security and allows teams to have security shift left from the beginning, instead of just leaving it at the end to find out this open-source library is insecure or having to rewrite the code in other ways or reuse a different library.

Sometimes changing those libraries or open-source requires a rewrite. I remember one time we had a vulnerability of some Java, and the solution was to use another Java. Using that another Java forced the developer to rewrite many components because there was a huge difference. This helps identify issues fast instead of waiting until the end to find out it is vulnerable and having to make changes.

The areas for improvement in Sonatype Lifecycle could be the UI. There is way to improve it as it has many tabs and nested sections. Sometimes when you look for something, if you are new to this, it might take you a little to get your head around things. This is something I feel they can simplify.

Also, the policy configuration is powerful, but at the same time, there is a steep learning curve. You need to make sure that you configure it correctly. You do not want to configure it in a way that blocks things.

If they improve the reporting, the UI, and the user experience, it would be beneficial. The design could be improved. If they add certain features and make it simple for the security analyst and to the user as well, it would help. Sometimes you have to look for many things to find a button that does something specific. They can do a good job fixing this.

Also, in the waiver management, it currently does not send notification. If some developer raises a waiver or adds a waiver to some component, we will not be notified. I have to go to the system to find out. This can be improved.

I do not have specific information about how many years I have been aware of Sonatype Lifecycle. Probably since I am aware, maybe four or five years. I could be wrong, but this is as far as I remember.

It is very, very stable. I hardly had any issue with it going down or something.

I think it is scalable, but being costly will make you revise what you want to do. If you have an expensive tool, you want it to work the bare minimum to cover the environment. It covers all our environment. I do not see any problem with the scalability.

I would give the same support rating for Sonatype Lifecycle as previous products. They are the same people.

I have not used or compared Sonatype Lifecycle to any similar products. Maybe there were tools in the past, but I was not here. This is the only thing I know.

We did not run the installers ourselves for the installation and deployment process of Sonatype Lifecycle. We are two teams and we have another team who do the administration, the installation, and the patching. We are more from the security side. We are the policy administrators. Another team handles the installation and setup. I am not aware of any problems. We have the support from the vendor themselves, and sometimes if they need help, they get the help.

Some developers did integrate Sonatype Lifecycle with CI/CD tools, but I am not aware of the details. I know they tried something. We use Azure DevOps mainly.

I really do not know how to quantify time or money savings from using Sonatype Lifecycle. For me to answer this, I need to be aware of everything. There are some savings, but I do not know how much. I cannot state it.

It is expensive. It is one of the pricier SCA tools in the market. You license their developer application, and it can be expensive at scale. If you want to scale, you just need to pay more. For us, we have the IQ Server and we have the firewall, which is already another separate license. So to have all together, it is an expensive environment to run, honestly speaking. If they can do something about that, it would be beneficial.

Automation of policy enforcement impacts my development process. You can build it in a way that stops the CI/CD itself if a library has a vulnerability or certain severity. You can be specific about things that stop the pipeline or if it has vulnerabilities or certain conditions. This helps a lot for creating security policies around applications.

Component health is very important. We can always see the health of the open-source component. It shows if it is vulnerable or not, what is the severity, is it banned, is it standard, is it not standard. The health is the same as when you say severity of something. Is it okay to be used or not?

I gave this product a review rating of 8 out of 10. Although Sonatype Lifecycle is one of the most expensive solutions at a rating of 10 for cost, it is worth the investment in certain areas. The time savings is significant because it allows the CI/CD to be more productive. Security adds complexity to development. If you develop alone, that would be different than developing with security in mind. This will ease the part of security because not everyone is aware of all security. Sometimes developers may know how to code, but they do not know how to code securely. This will save them time and provide hints and alarms. It speeds the process of adopting to security and adopting to DevSecOps. It also protects the environment because you sometimes pay for something that is valuable to secure it. In these areas, it is worth the buying, although it is costly.

I have used Sonatype Lifecycle for one year, primarily as a part of DevSecOps and software composition analysis initiatives focused on my application security project, which involves identifying and managing open-source dependencies risks within application environments.

For Sonatype Lifecycle, I actually use it for two purposes in application security: security composition analysis (SCA) and Static Application Security Testing (SAST), with the intention to identify code-level vulnerabilities when developers write any code, allowing me to scan the code, prioritize vulnerabilities, and fix those areas to reduce overall application risks.

Before using Sonatype Lifecycle, I used to get vulnerabilities in the deployment phase, also known as Dynamic Application Security Testing (DAST), but after implementing Sonatype Lifecycle, it adds an additional security layer by allowing me to conduct SAST and SCA scans early in the coding phase, enabling me to prioritize and remediate vulnerabilities as soon as possible, which reduces time and effort.

In my opinion, the strongest feature of Sonatype Lifecycle is its ability to provide continuous visibility and governance over open-source dependencies throughout the software development lifecycle, with the most standout aspect being its effective integration of security directly into DevSecOps workflows instead of treating security as a separate, post-development activity.

The policy-based governance and vulnerable component rejection capabilities are tremendously valuable for my team because they shifted security enforcement earlier in the lifecycle. For example, I configured policies to flag or block builds with open-source components with critical vulnerabilities, and that was impactful when Sonatype Lifecycle detected a high-severity vulnerability during a build process.

Overall, Sonatype Lifecycle has a very positive impact on the organization, particularly in improving software supply chain security and DevSecOps practices, with measurable improvements including earlier detection of vulnerabilities and faster remediation cycles.

I have definitely observed measurable operational improvements after integrating Sonatype Lifecycle into my workflows, highlighted by a noticeable reduction in vulnerable open-source components progressing to production stages, allowing me to remediate them before deployment.

While Sonatype Lifecycle provides strong value for software composition analysis and software supply chain security, one area for improvement is alert prioritization and noise reduction, especially in larger development environments.

The primary area for improvement I mentioned is alert prioritization and noise reduction, in addition to improving dashboard and reporting customization.

I have used Sonatype Lifecycle for one year.

Sonatype Lifecycle is pretty stable and works fine.

In my experience, Sonatype Lifecycle scales well for enterprise DevSecOps and software supply chain security use cases, particularly in environments with multiple development teams and a large number of applications and dependencies.

The customer support for Sonatype Lifecycle is very helpful, and they are technically sound, providing positive feedback.

Before Sonatype Lifecycle, I used a DAST solution called Qualys for application security, and this is my first tool for SAST and SCA scans.

From my point of view, once I introduce Sonatype Lifecycle with the DevSecOps pipeline, it offers automated vulnerability scanning, prioritization, and allows me to focus on risk assessment and remediation, saving me about 40% in time and effort.

If you are working in a DevSecOps or application security project and want to prioritize vulnerabilities early, implementing Sonatype Lifecycle in your project will be helpful in addressing risks before they escalate. I provided this review with a rating of 8.

Whenever we have builds, we upload our builds or artifacts to Sonatype Container. This is the basic purpose. Sonatype Container makes cleanup and uploading artifacts easy with its clear UI for management.

Sonatype Container is a reliable artifact manager. Although I do not have a comparison at the moment, it has consistently been a good choice for our organization. Its management features are effective, and the UI is clear, making it easy to upload and manage artifacts. Additionally, the use of Sonatype Container ensures efficient cleanup and file handling.

Sonatype Container can accommodate bigger file sizes for artifacts and improve performance, especially when dealing with large files. Moreover, the RBAC controls could be more simplified in a more human-readable language.

I have been working with Sonatype Container for more than five years.

I would rate the stability as eight out of ten.

Technical support from Sonatype is not much needed. I had a problem once while creating a repository when the artifacts uploaded were not showing up, but this may have been due to configuration details.

We have been using Sonatype Container for a long stretch of time and have not tried anything else.

The setup is simple; however, if we consider RBAC, the roles we assign to users could be simplified. The response from the roles assigned to the artifacts should be more human-readable.

Pricing is out of my context as a developer. This is known by the project managers.

I would rate the overall solution as eight out of ten.

We use Sonatype Lifecycle primarily as a binary repository management solution for managing software artifacts. Our company has a large stack of tools for software development, and Sonatype Lifecycle is part of these tools. We use it solely for managing software artifacts without utilizing the software composition analysis or the vulnerability checking capabilities. We are expanding our clients and services as part of Digital Service of Brazil.

The most valuable feature for us is Sonatype Lifecycle's capability in identifying vulnerabilities. It has a large portfolio for vulnerability analysis, making it a leader in vulnerability checking. In comparison, the performance of other products, like JFrog's, does not reach the same level in identifying vulnerabilities. Additionally, Sonatype Lifecycle is very stable, especially in managing binary artifacts for over fifteen years with minimal problems, even with more than 700 developers working on a single node.

Both JFrog and Sonatype should redesign their products to separate the binary repository management solution from the software composition analysis solutions. We prefer to purchase the binary repository management solution independently, but they offer both together, which increases costs. This integration is good but raises the price, being a significant issue for us. We also noticed a lack of detailed information for configuring Sonatype Lifecycle for high availability and data recovery.

I have used Sonatype Lifecycle for over fifteen years.

Sonatype Lifecycle is very stable, especially in the binary repository management use case for managing binary artifacts. We have not experienced any significant issues over the fifteen years of use.

Both Sonatype and JFrog have solutions for high availability and data recovery, but Sonatype is more complex to configure. JFrog is easier to configure for high availability as it does not require extra components. It handles high availability at the database level, such as synchronizing JFrog repository servers without complicated configurations.

We use Sonatype Lifecycle in its open-source software edition, so we do not have experience with their customer service or technical support.

According to my calculations, if you are working with up to 200 developers, Sonatype is cheaper than JFrog. However, for larger numbers like our case with 1,000 user licenses, JFrog becomes much more cost-effective, roughly ten times cheaper than Sonatype. Their licensing models are different, impacting the price depending on the number of developers.

I compared Sonatype Lifecycle with JFrog Artifactory and Xray.

Overall, I would rate Sonatype Lifecycle a nine out of ten.

We use Sonatype Lifecycle for scanning our SCA product, software composition analysis. It is a category of product we use to scan third-party packages imported into the source code like Java, Node.js, or Python.

It reports back as an enterprise product with UI reports and is very useful. We integrate it into our pipelines, generate reports, and our developers engage with it to fix issues and ensure the software supply chain is secure.

The solution provides a comprehensive overview of dependencies and their security status. The onboarding process is straightforward, and the UI is very clear. The integration into our CICD pipeline enables us to continuously monitor code changes and identify new vulnerabilities. This ensures we can address issues proactively. Lifecycle effectively manages dependencies and highlights unsecure packages. It does what it does better, with integration into other Sonatype products. This integrated ecosystem is advantageous for us.

It is a bit narrow, and we are expecting more features, especially with respect to SBOM and other detections. It is specific to only one category, and we would like them to add more diverse application security features. We expect products to do multiple things. It only does one thing, and we want it to expand its capabilities.

We have been working with Sonatype Lifecycle for four years.

The product is stable and works as expected. There are no performance or reliability issues.

I find the solution scalable.

The technical support is good. I would rate them as eight out of ten. They are helpful when we raise any tickets.

We did not use another solution before this one.

The initial setup is not straightforward as it includes databases, yet the documentation is good, and we did not face any issues. The support is good, and the setup went smoothly.

It is a security product, so we installed it in our automation environment without tweaking anything. We brought users in, provided an overview of how developers should use it, and integrated it into a few applications before rolling it out to all.

We have seen cost savings and efficiency improvements as we now know what happens in what was previously a black box. The ROI is around two years, however, security improvements are hard to quantify.

We didn't evaluate other options since the product aligns with our ecosystem, enabling it to work well with other solutions we use.

I recommend it because it integrates well with other Sonatype products and does its job effectively.

Overall, I would rate Sonatype Lifecycle as seven out of ten.

I work for a service-based company where we develop solutions based on customer requirements. That server was currently put up.

I've also worked with product-based companies, developing software products for end-user requirements. That's my background, working broadly in telecom and healthcare.

This solution is for the client, and we do have internal customers who have been using this solution too.

Sonatype Lifecycle primarily has two main products:

1. Sonatype Nexus and
2. Sonatype Lifecycle.

Lifecycle is mainly used for firewall management. If any issues are detected during the build process, they will be flagged, and each port can be addressed based on firewall and code scanning reports.

Essentially, it streamlines the process, allowing us to easily identify code snippets that need attention and then act upon those findings.

It's heavily integrated within our organization due to our adherence to HIPAA regulations, which are critical for protecting health information. We ensure regulatory compliance is incorporated into both our code and the applications we develop.

• Detailed Violation Reports: The violation reports provided by Lifecycle are key, giving specific details on the types of violations and identifying the component within the application. Even with multiple components like web, app, and database tiers, each is evaluated separately through individual pipelines, and reports are provided for each.

• Version Tracking: Another important aspect is the version details, showing which version is causing issues. We follow a standard release naming convention (major, minor, patch), so we can easily see which version is problematic.

• Dependency Management: Additionally, we can address dependency-related information at a granular level, identifying component versions causing build blockages. This is a very helpful feature.

With Sonatype, I primarily work with the Nexus Repository. I like it the most because it can store many artifacts generated after applications are built. These artifacts can be retrieved at any time.

Another valuable aspect of Sonatype is that it combines Lifecycle with the repository. The Lifecycle component integrates into every stage of the release, starting from code checkout and throughout the build process. This integration gives us insights into the code's quality and overall health.

Additionally, Sonatype seamlessly integrates with other tools like GitLab, providing continuous integration, delivery, and deployment capabilities.

It offers comprehensive reports on each stage, facilitating static code analysis and improving our understanding of code quality. All these integrations help provide valuable feedback to developers and stakeholders.

Mitigates security vulnerabilities:

It primarily analyzes code and provides vulnerability check results through the IQ Server. This server takes the application configuration and details, then provides a dashboard showing the vulnerabilities as critical, low, or high.

This is based on the policies defined in Lifecycle. Besides the default policies, we have custom policies that can be defined. These features evaluate the code and present those reports in the dashboard.

While Sonatype Lifecycle effectively manages artifacts in Nexus Repository and performs code firewall checks based on rules, it has the potential to expand further.

I am looking forward to additional features similar to SonarQube, especially since licenses are often split per component. SonarType could integrate cloud-based capabilities, addressing the increasing shift towards cloud workloads. While there have been demos and discussions around this, significant progress on scanning and analyzing cloud images remains to be seen.

I am looking forward to Sonatype incorporating these enhancements, particularly in regard to cloud-based features. On-prem workloads are getting to the cloud workloads.

• I would like to see more cloud-related insights, such as logging capabilities for the images we use and image scanning information.
• Additionally, it would be beneficial to have insights into the stages of dependencies and ensure they comply with standards. If there are any violations in respect to CVSS reports,
• Integrating CVSS (Common Vulnerability Scoring System) report rules into the Lifecycle module to detect and report violations would be valuable. I am hoping to see these enhancements from Sonatype in the future.

On the security side, I think there's a lot of development needed. There are many security tools on the market, like open-source ones, that Sonatype doesn't integrate with.

I have experience with this product.

The stability of the product is very normal. If we don't bump it up with minor releases, and instead use the stable releases, there are no major issues. So far, the stability is perfectly fine.

I would rate the scalability an eight out of ten.

Earlier, licenses were specific to on-premise servers, but now, Sonatype is also available in the cloud, offering more flexibility. Now, we can bump it up if required. We can increase the number of user licenses as needed by contacting the Sonatype team.

We regularly evaluate our license usage and adjust based on our needs. For example, we initially had 100 licenses, but after analyzing usage patterns and integrating another team, we increased it to 200.

So, scalability is not an issue.

The support was good. However, getting the right resources for specific activities is a problem.

Once an issue is identified, we need to raise a user request, which might become a development request, leading to long wait times. This is where we experience delays and needs improvement.

Another tool that is equivalent to Sonatype is JFrog, but it does not have Lifecycle kind of features.

But, we can compare the Sonatype Nexus repository with JFrog Artifactory. We also have other options like Azure Artifacts in the cloud.

I would rate my experience with the initial setup a nine out of ten, with ten being easy.

The installation itself is quick, but the configuration takes longer, especially with custom policies. If you use the default policies, it's much faster.

The configuration needs to be tailored to the specific requirements of the team or application. Installation can be completed in three to four hours, but configuration may take a couple of days.

Deployment model: It is deployed both on the cloud and on-premises.

Deployment resources: It doesn't require many resources. One engineer and another person should be able to handle it, especially for the policies and other details. Installation and setup are not difficult.

However, ongoing maintenance is required, so an additional person might be helpful. Is the requirement solely for Sonatype, or do you have other tools to maintain as well?

I successfully set it up from scratch for my organization, conducted training sessions for the development team and leadership, and collaborated extensively with the Sonatype team for over eight years.

Steps for the deployment process:

1. First, we get the bundle. Once we receive the bundle, we will review the installation tips and identify the server for installation. The installation server is designed based on the environment, considering CPU, RAM, storage requirements, and database choice (Oracle or PostgreSQL). After all, the database is key.
2. We download the package bundle from the website, which includes the installation script and a configuration file. The configuration file defines the connection details to the database. This is usually handled by the admin ID.
3. The next step is to create roles for the development team and other relevant teams, assigning users to these roles. The most time-consuming part is defining the custom policies tailored to our organization's specific needs, as we have numerous applications running with different teams and product lines.
4. Once the policies are defined, we integrate Sonatype with the CI/CD pipeline. This allows us to run scans, generate reports, and start using the tool effectively.

In terms of Sonatype, it's definitely worth it. The software is valuable. However, I'm expecting more additional features and frequent releases, as major releases take a long time. I think the Sonatype development team should release updates with additional features more often.

I would rate the pricing a seven out of ten, with ten being expensive. The price is high.

It depends on the number of licenses. The price increases based on the fact bundle you are collecting. The number of licenses depends on the organization and how many we have.

My advice:

Sonatype Lifecycle has a lot of uses based on the user base. It's licensed based on support, not per user. So, if a team has 200 developers, I would recommend starting with a smaller number of licenses, like 50 or 75, and increasing it later if needed, rather than buying 200 licenses upfront. They can always compare and adjust based on their usage.

Overall, I would rate it an eight out of ten.

We use this solution for libraries in our applications that need to be updated.

The solution is very easy to use.

Improvements are needed as per customer requirements.

I have been using Sonatype Lifecycle for one year.

The scalability is a ten out of ten.

Overall, I would rate the solution a ten out of ten.

Our primary use cases involve monitoring and securing our software supply chain. We use it to proactively identify and block any potentially insecure components from being downloaded, ensuring our firewall remains robust. Additionally, we use the platform to analyze both deployed and developing code throughout the development lifecycle.

The most valuable function of Sonatype Lifecycle is its code analysis capability, especially within the specific sub-product focusing on static analysis. This feature, particularly tailored for Java code, has been crucial in identifying and addressing vulnerabilities in our software.

There is room for improvement in the code analysis aspect of Sonatype Lifecycle, specifically in the area of deployment security. While the product effectively scans components and provides threat intelligence, it requires additional manual effort to ensure that the configuration of the product during deployment is done securely.

When it comes to new features, I would find it incredibly beneficial if Sonatype Lifecycle could integrate with deployment tools, enabling real-time identification of any vulnerabilities as developers push code to production.

It is a quite stable solution. I would rate the stability as a seven out of ten.

I would rate the scalability of the solution as a ten out of ten. It is suitable for any business size.

I would rate Sonatype's technical support a solid ten out of ten. They are highly engaged, conduct weekly meetings to discuss the product roadmap and competition, and even bring in engineers to provide hands-on guidance on using the product.

Setting up Sonatype Lifecycle can be complex, possibly influenced by deployment choices. While I haven't explored the latest architecture, there is potential for a simpler SaaS deployment. It is available both as an on-premises and cloud-based hybrid solution to suit different preferences and needs.

I would rate the affordability of the solution as an eight out of ten.

Overall, I would rate Sonatype Lifecycle as a six out of ten. It is a solid product with some room for improvement.

We use the product as a SaaS analysis tool. We review static code. It allows you to find vulnerabilities.

The value that combining Fortify and Sonatype is that we use Fortify as a SaaS analysis tool. We review static code and Sonatype allows you to find vulnerabilities.

I use it as a security center. I review it for any kind of issues, whether for proof or to deny, the source code, the findings, and then the enterprise can go back and provide their recommendation for how to fix the issue. It is used to scan the code base.

As a security analyst, I like the management view. From there, you can review the code and review findings in order to approve, deny, or recommend. Their Software Security Center, which acts as a portal, is quite useful. It's a good overview. You can really see what's happening after you've developed something.

Fortify's AppSec testing is great for application portfolio inventory and project releases. It works both at a portfolio level and also at a project level.

They also give you the capability to click train of all your vulnerabilities that happened within Apache Crossroads support. You give them a history to keep track of them, how they've been developed, how they've been saved, to give you a way of tracking your issues and how they get resolved.

It's pretty easy to find vulnerabilities. Then, you go to the source. It is very good at tracking to see where the data or the issue enters into your source code so you can track it or go back to where it started.

Fortify helps remediate potential vulnerabilities by using more accurate, reliable results. They offer recommended remediation. I can go to the website tools to resolve issues and search for remediations. This helps our developers to build more secure code from the start.

It has reduced vulnerabilities. We've never had issues when we ran our scans. We're notified, and we're able to identify most of our vulnerabilities and fix them before anything goes to production. If you're running this on your CI/CD pipeline, notifications are in real-time.

The level of detail is very informative. It provides you with recommendations on how to fix items. And they provide you with other resources available for how to address the issues. You can also see the root cause.

It works well with cloud-native applications.

Fortify helped us to free up staff time since it helps us resolve issues faster.

It's helped us save costs as, if we catch a vulnerability faster, it's easier to fix than later.

Fortify and Sonatype help maintain compliance with the applicable regulations. We mostly use Sonatype for compliance and licenses. By combining both solutions together, it enables you to solve a lot of issues that may occur in the future.

It would be nice if they had a version suitable for single developers that could be more cost-effective and maybe faster to learn.

I've been Fortify for two or more years.

I've never had an issue with the solution crashing.

I've never had issues with scaling.

I've never had to contact technical support.

I was not involved with the initial deployment.

We only integrated the product with one other solution. It was easy to do so.

There is some general maintenance needed, such as adding or removing users and projects and things of that nature.

Their licensing is expensive.

I do not use the open-source components of Fortify. However, we use other tools for open-source stuff.

I'd advise people who are still using manual methods to find vulnerabilities to adopt some sort of scanner to cut the time spent by 100%.

I'd rate the solution ten out of ten.

I would advise other potential users that you need to make sure your source code can work with Fortify.