<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Armory - Medium]]></title>
        <description><![CDATA[Continuously deploying software at any scale should be achievable and easy for all developers. Armory’s developer-first declarative and flexible continuous deployment solutions make that a reality. - Medium]]></description>
        <link>https://medium.com/armory?source=rss----6f479360264a---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Armory - Medium</title>
            <link>https://medium.com/armory?source=rss----6f479360264a---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 20:13:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/armory" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[How Armory Simplifies Exposing Services in Ephemeral Kubernetes Environments]]></title>
            <link>https://medium.com/armory/how-armory-simplifies-exposing-services-in-ephemeral-kubernetes-environments-e7d937999f8e?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/e7d937999f8e</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[networking]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[qa]]></category>
            <category><![CDATA[kubernetes]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Tue, 14 Mar 2023 23:41:02 GMT</pubDate>
            <atom:updated>2023-03-14T23:41:01.994Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/917/1*4uNTjKHvbWRwryide9oRXw.png" /></figure><p>As a developer, it&#39;s important to be able to verify UI and API functionality of services before deploying them to production. Often, this requires setting up complex networking rules, or coordinating different teams using shared environments. <a href="https://www.armory.io/products/continuous-deployment-as-a-service/">Armory Continuous Deployment-as-a-Service</a> simplifies this by enabling developers to easily connect to any service it deploys, without additional network configuration. This is especially useful when deploying to ephemeral Kubernetes environments, such as those created for a specific PR, since network configuration is otherwise often environment specific. In this blog, we&#39;ll walk you through why you may wish to use this feature, and how to use it to provide a preview of a service.</p><h3>What is an Ephemeral Environment?</h3><p>Many teams need to create temporary environments allowing individual developers to test individual changes before their code merges to main or deploys to shared environments. Creating a namespace within a development cluster for a particular PR or branch is a common implementation of Ephemeral Environments.</p><h3>Deploying to an Ephemeral Namespace with Armory</h3><p>When you deploy with Armory, you specify a list of Kubernetes manifests we will deploy. If you include a namespace manifest, we will create that namespace. Similarly, in your CD-as-a-Service deploy.yml you can <a href="https://docs.armory.io/cd-as-a-service/reference/ref-deployment-file/#targets">override the namespace</a> all other manifests deploy to. This allows you to easily create and deploy into an ephemeral namespace using the name of your branch.</p><h3>Existing Kubernetes Options to Expose Services</h3><p>With an ephemeral environment developers historically had a few options to connect to the Kubernetes services that they deploy. Some techniques require the user who connects to the service to have access to the Kubernetes cluster, which is not always realistic. Others require extensive Kubernetes knowledge to configure.</p><h3>Port-forward with Kubectl</h3><p>The kubectl command line allows you to run kubectl port-forward service/service-name portnumber to allow you to connect to any service via a port on your local computer. While this is the easiest native way to connect to a Kubernetes service, it includes several downsides:</p><ol><li>A developer must have direct access to the Kubernetes cluster in order to issue a port forward</li><li>It is not practical to share the URL of the forwarded port with a teammate who lacks access to the cluster because the connection is through the developer&#39;s personal computer.</li><li>It is usually not practical to run integration tests requiring a deployed environment using the port forward.</li><li>if your computer goes to sleep it will interrupt any connections through the port-forward.</li></ol><p>In a world of laptops and firewalls, port-forwarding can be useful for taking a quick look at your services, but is not viable for sharing URLs or running long-running tests.</p><h3>Configure a Load Balancer</h3><p>Changing the ServiceType to LoadBalancer exposes Kubernetes services to an external network. If that network is itself internet accessible, this can provide a reasonable path to access. However, Accessing the load balancer may require additional networking outside the cluster. Load balancers are also dedicated infrastructure that often costs money.</p><h3>Configure Ingress</h3><p>Ingress allows a single Kubernetes load balancer to route traffic from multiple child directories to multiple independent Kubernetes service objects. This allows you to reuse a single load balancer for multiple service objects. Unfortunately, configuring ingress can be complicated and error-prone. Additionally, many popular Ingress providers require the specific LoadBalancer URL as part of the configuration. This results in ingress configuration being less portable--the configuration is unique to each Kubernetes environment.</p><h3>How Armory Can Forward a Service</h3><p>Armory can leverage its remote network agent to expose a preview URL for any Kubernetes service it deploys. CD-as-a-Service generates a cryptographically secure URL for applications developers. You can share this url with teammates and stakeholders who need to review the deployed functionality. This enables developer access to deployed services on-demand without a dependency on other teams to set up networking.</p><p>This is similar to the way the kubectl port-forward command works, only instead of running it on a local developer laptop, we run it from the armory side. Similarly, instead of exposing the URL on a particular port, we generate a unique child URL for the service. Armory uses a cryptographically secure random number generate to generate this URL&#39;s unique GUID. After a given amount of time, Armory automatically shuts down this URL so it is no longer accessible. While the URL is cryptographically secure, Armory still recommends only using it to expose services in test environments, not production environments. This is because the preview url does not require any additional authentication beyond that of the exposed service.</p><p>To see this functionality in action, you can watch this <a href="https://drive.google.com/file/d/1Ivfazbb7DGzOOhVRuHZV3x3EyixZenek/preview">demo video</a>. If you&#39;d like to try it hands on, you can <a href="https://www.armory.io/products/continuous-deployment-as-a-service/">signup to try Armory CD-as-a-Service for free</a>. In the setup wizard, choose to deploy Armory&#39;s sample application. Once the application deploys to the first environment, click into that environment, and you will be able to open the exposed service to view the deployed application.</p><h3>Configuring Armory CD-as-a-Service to Forward your Service:</h3><p>If you are using Armory CD-as-a-Service to deploy your application, adding the preview service is easy. Your application&#39;s configuration already has either a canary or blue/green strategy. Simply add <a href="https://docs.armory.io/cd-as-a-service/reference/ref-deployment-file/#strategiesstrategynamecanarystepsexposeservices">the exposeService step</a>, specify which services to expose, and for how long they should be exposed. Preview links will be available when you click into an environment from your deployment UI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DuBmFyCQ8BSQNkFfeWkjNA.png" /><figcaption>Clicking into your exposed service from the UI</figcaption></figure><h4>Example Configuration for a blue-green deployment:</h4><pre>blueGreen:<br>      redirectTrafficAfter:<br>        - exposeServices:<br>            services:<br>              - potato-facts-internal<br>              - potato-lies-internal<br>            ttl:<br>              duration: 30<br>              unit: MINUTES</pre><h4>Example Configuration for a canary deployment</h4><pre>canary:<br>      steps:<br>        - exposeServices:<br>            services:<br>              - potato-facts-internal<br>              - potato-lies-internal<br>            ttl:<br>              duration: 30<br>              unit: MINUTES</pre><h3>Conclusion</h3><p>Using the Expose Service feature in Armory CD-as-a-Service is a great way to preview your services before deploying them to production. By following the steps outlined in this blog, you can easily preview your service using the Expose Service feature, and never need to use <em>kubectl port-forward</em> from your laptop again!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7d937999f8e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/how-armory-simplifies-exposing-services-in-ephemeral-kubernetes-environments-e7d937999f8e">How Armory Simplifies Exposing Services in Ephemeral Kubernetes Environments</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Enforce Least Privilege & Separation of Duties during Continuous Deployment]]></title>
            <link>https://medium.com/armory/enforce-least-privilege-separation-of-duties-during-continuous-deployment-355c603b291a?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/355c603b291a</guid>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[compliance]]></category>
            <category><![CDATA[information-security]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Thu, 02 Feb 2023 16:57:31 GMT</pubDate>
            <atom:updated>2023-02-02T16:57:31.240Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Originally published on the <a href="https://www.armory.io/blog">armory.io blog</a>, which covers continuous deployment and other topics related to DevOps.</blockquote><p>Role-based access controls (RBAC) are an essential part of any secure Continuous Deployment Platform. RBAC enables enforcement of the <a href="https://www.paloaltonetworks.com/cyberpedia/what-is-the-principle-of-least-privilege#:~:text=The%20principle%20of%20least%20privilege%20(PoLP)%20is%20an%20information%20security,to%20complete%20a%20required%20task.">principle of least privilege</a> by limiting access to applications and services to the minimum set of users. RBAC enforces <a href="https://blog.eliassen.com/separation-of-duties-and-devops">separation of duties</a> thorough role-based manual approvals. This helps to meet these common requirements and provides an additional layer of security within your DevOps organization.</p><p>This blog post discusses how <a href="https://www.armory.io/products/continuous-deployment-as-a-service/">Armory Continuous Deployment-as-a-Service</a> uses automation and role-based access controls to ensure that changes to production applications are properly reviewed before being released. It also describes how to restrict application access by role. Finally, we’ll provide an overview of the Armory platform’s capabilities, including <a href="https://docs.armory.io/cd-as-a-service/tasks/tenants/add-tenants/">tenant</a> and <a href="https://docs.armory.io/cd-as-a-service/tasks/iam/create-role/">role management</a>, configuration as code, and <a href="https://docs.armory.io/cd-as-a-service/tasks/deploy/role-based-manual-approval/">role-based approvals</a>.</p><h3>What Are Role-Based Access Controls?</h3><p>RBAC is a security system that allows administrators to limit access based on the roles of users. This ensures that only authorized users can access or modify sensitive data and systems, and can require certain users to perform certain tasks in order to <a href="https://www.armory.io/blog/upgrading-your-management-style-for-devops/">ensure separation of duties</a>.</p><p>RBAC uses roles to define permissions. Each role has its own set of permissions and restrictions. For example, a user with the “administrator” role might be able to access all applications and services, while a user with the “WebUI developer” role might only be able to access the deployment of the Web UI service.</p><h3>Separation of Duties</h3><p>Many companies have <a href="https://drata.com/blog/soc-2-controls">SOC controls</a> that ensure their applications are stable and secure. SOC often requires a <a href="https://info.cgcompliance.com/blog/5-ways-you-could-derail-your-soc-2-audit">separation of duties</a>: Code requires approval before production deployment. This often takes the form of manual role-based sign-offs. For example, someone from QA may need to sign-off that tests passed, and someone from InfoSec may need to sign off that security scanners passed. Until you <a href="https://www.armory.io/blog/using-your-existing-automation-in-your-deployment-pipeline/">implement full automation</a>, role-based approvals allow you to enforce and audit separation of duties around these tasks within your deployment pipeline.</p><p>Historically these process typically starts with a developer creating a change request. An authorized user must review this request. If approved a release manager deploys the change to production.</p><h3>Using Role-Based Approvals to Enforce Separation of Duties</h3><p>Using CD-as-a-Service developers can now start the release automation process. When the code is ready for approval the required approver can be notified, and simply click a button. After approval the change deploys automatically. This prevents unauthorized changes. It also provides visibility into manual processes so that they can be automated.</p><p>To enable separation of duties Armory Continuous Deployment-as-a-Service allows any Manual approval to optionally specify a list of roles. Only a user with one of these roles is able to issue the approval. Other users can see that an approval is needed, and can see the list of roles authorized to issue it. This example shows an environment, <em>Security-Scanning</em>, that requires an approval by the <em>InfoSec</em> role before it will proceed to any downstream environments.</p><pre>Security-Scanning:<br>    account: demo-staging-cluster<br>    strategy: rolling<br>    constraints:<br>      afterDeployment:<br>      - pause:<br>            untilApproved: true<br>            requiresRoles:<br>            - InfoSec</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/724/1*tEGTnk7kcEmgYHo3REosTg.png" /><figcaption>Other users can see who must approve.</figcaption></figure><h3>Moving Beyond Role-based Approvals</h3><p>While role-based approvals are a great way to start on your CD journey, many companies remove manual approvals from their deployment pipeline long-term. Once automation of a manual check is available it can replace the manual approvals. The role that approved the change can instead approve changes to the automation to continue enforcing separation of duties. Audits should check the approval of automation changes. Audits should also check that all changes were approved by the automation.</p><h3>Enforcing Principle of Least Privilege Through Tenants</h3><p>Armory CD-as-a-Service can break it&#39;s configuration up into multiple secure tenants. This allows particular applications or teams to have their own dedicated security zone within Armory CD-as-a-Service. A tenant contains a set of Kubernetes clusters, applications, secrets, etc. Roles grant a particular access level within the scope of a tenant. Grant one or more roles to each user to give them access to their team&#39;s resources. This allows you to easily break your application access up by team, while still supporting users who need access to applications owned by multiple teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*b9275VIAVYJkTWqQ" /><figcaption>The High-Level CD-as-a-Service Security Model. Tenants enable enforcement of the principal of least privilege during continuous deployment.</figcaption></figure><p>The principal of least privilege requires that teams have access to the minimum permissions needed to do their job. Enforce least privilege by creating a tenant per team and giving each tenant only the resources needed for that team&#39;s applications.</p><h3>Maintaining your RBAC as Code</h3><p>Modern source control systems allow advanced permissions, automated validation and change control. They are also familiar tools for the typical team setting up a CD tool. Because of this Armory CD-as-a-Service took an &#39;as-code&#39; approach to implementing it&#39;s RBAC rules. CD-as-a-Service defines the RBAC configuration as yaml. You can update this yaml through git, just like any other code. When changes occur, your CI system can invoke the Armory CLI to automatically apply the updated RBAC configuration. This provides full audibility and change control to ensure your security configuration is itself secure.</p><p>This example RBAC configuration for Armory CD-as-a-Service creates a tenant-restricted &#39;admin&#39; and &#39;non-admin&#39; role for each of two teams.</p><pre>tenants:<br>- Team1<br>- Team2<br>roles:<br>    - name:Team1 Member<br>      tenant: Team1<br>      grants:<br>        - type: api<br>          resource: deployment<br>          permission: full<br>    - name:Team1 Admin<br>      tenant: Team1<br>      grants:<br>        - type: api<br>          resource: tenant<br>          permission: full<br>    - name: Team2 Member<br>      tenant: Team2<br>      grants:<br>        - type: api<br>          resource: deployment<br>          permission: full<br>    - name: Vanguard Admin<br>      tenant: Team2<br>      grants:<br>        - type: api<br>          resource: tenant<br>          permission: full</pre><h3>Conclusion</h3><p>Role-based access controls are an essential part of any secure IT infrastructure. By limiting access to certain tenants, companies prevent users from modifying other team’s applications. Platform teams and developers can also leverage role-based approvals to ensure separation of duties within their application.</p><p>The Armory platform provides an automated and secure way to manage role-based access controls. It includes features such as tenant and role management, configuration as code, and role-based approvals. These features prevent users from making unauthorized changes. Do you want a secure and flexible CD solution for Kubernetes that can leverage RBAC to ensure the principle of least privilege and separation of duties? <a href="http://go.armory.io/signup">Sign up to try Armory CD-as-a-Service</a> for free today.</p><h3>Who is Armory?</h3><p>We believe deploying software safely and continuously at any scale is at the center of achieving your competitive advantage and can accelerate time-to-market. Safe, reliable deployment should be easy to understand and achieve for any developer. Write code. Package artifacts. Choose targets. Hit deploy — This is every developer’s dream deployment scenario.</p><p>Armory makes this dream a reality by enabling development teams to confidently deploy their software every time; easily, reliably, safely, securely, and continuously.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=355c603b291a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/enforce-least-privilege-separation-of-duties-during-continuous-deployment-355c603b291a">Enforce Least Privilege &amp; Separation of Duties during Continuous Deployment</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Continuous Deployment Creates Technology Cost Savings]]></title>
            <link>https://medium.com/armory/how-continuous-deployment-creates-technology-cost-savings-d23deabb92c3?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d23deabb92c3</guid>
            <category><![CDATA[automation-software]]></category>
            <category><![CDATA[cloud-cost-optimization]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[cloud-cost-management]]></category>
            <category><![CDATA[cost-savings]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Fri, 04 Nov 2022 17:32:33 GMT</pubDate>
            <atom:updated>2022-11-11T18:22:16.129Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*3DteJYljctzijFHJcNa8qg.png" /><figcaption><a href="https://commons.wikimedia.org/wiki/File:Surprised_Cartoon_Woman_Getting_Money_Online.svg">Image Attribution</a></figcaption></figure><p>As our economy tightens, many companies need new ways to save money. The cost of IT, the cloud, and software development make up <a href="https://techvera.com/how-much-should-a-company-spend-on-it/#:~:text=The%20average%20small%20company%20(less,spend%20a%20relatively%20tiny%203.2%25">a significant percentage of modern organizational budgets</a>. This blog discusses how Continuous Deployment (CD) practices can convert your spend from <a href="https://www.linkedin.com/pulse/you-running-changing-your-business-andy-mowat/">run-the-business (RTB) to change-the-business (CTB) spend</a>. It explains how CD can create technology cost savings, and allow your team to accomplish more with less. It also discusses my experiences in building IT automation and cost management software, and why automation is critical for success in this economy.</p><h3>Will Automation Cause Layoffs?</h3><p>I first joined a technology automation company back in 2006. A common objection we heard during our sales cycle was ‘if I automate that, I’ll be out of a job’. In reality, this never happened. In fact, when the 2008 recession hit, we saw the opposite. Management viewed the teams that were automating things as more productive. They were the last to be let go — not the first.</p><p>I have never met an executive who wants to lay anyone off. Before laying off workers, many companies instead stop hiring backfills. This is what technology teams should optimize for. In this economy, assume that if one of your teammates leaves, you won’t get a replacement for them. Prepare for this eventuality by improving your team’s efficiency through automation… Don’t wait for that backfill to not come because you will no longer have the available capacity to automate. Before the layoffs, additional automation will make you more nimble. It will help you save on your technology costs, and can help you avoid the layoffs in the first place.</p><h3>Making a Business Case for Continuous Deployment During a Recession</h3><p>After the 2008 recession I worked on software to help CIOs manage technology spend. Historically technology spend has been a black box for the business, and it is an <a href="https://www.gartner.com/en/newsroom/press-releases/2022-10-19-gartner-forecasts-worldwide-it-spending-to-grow-5-percent-in-2023">ever growing amount of money</a>. CIOs need to understand how to control this spend and scale it relative to revenue. Yet, CIOs were not only looking for technology cost savings. They were also seeking ways to spend money more productively. The easiest expenses to justify are ones that directly sell products and drive revenue. The remaining costs can be broken up into two large categories:</p><ul><li>RTB costs keep your services running, but don’t improve how they function.</li><li>CTB costs focus on improving existing processes and functions to make the business more efficient.</li></ul><h3>The Importance of CTB/RTB In creating Technology Cost Savings</h3><p>Many CIOs focus on changing RTB cost into CTB cost so that they spend less while delivering more.</p><p>The ability of a technology organization to innovate can be effectively measured by this <a href="https://www.itopia.ch/media/it_cost_survey_2019.pdf">CTB/ RTB ratio</a>. This number is the percentage of spend that is improving HOW services are delivered, as opposed to simply delivering services. Automation initiatives and Continuous Deployment initiatives are both classes of CTB spend. Building new applications is also CTB spend. However, there is a key difference between new application spend and Continuous Deployment or automation spend. New Application spend creates ongoing maintenance costs, and thus decreases the CTB/RTB ratio over time. However, Continuous Deployment and automation allow you to spend less on RTB and redirect those resources to CTB. IE, automation and Continuous Deployment are CTB spend that improves your CTB/RTB ratio while realizing overall technology cost savings.</p><p>When faced with budget cuts, CIOs are looking for ways to do more with less. As the economy tightens, growth will slow, revenue may shrink. This creates budget cuts whether you automate or not. As budgets shrink, less efficient businesses die as they lose their ability to innovate, and are thus out competed. When a budget cut happens, management is typically looking for ways to minimize the business impact of those cuts. They want to maximize the CTB/RTB ratio even when they need to shrink total spend. Automation allows for this, you just have to show your executives the opportunity and help find alternate technology cost savings.</p><h3>Creating Technology Cost Savings While Continuing to Innovate</h3><p>Many companies have tools they don’t need. Many also have tools that allow them to do with 1 person what would otherwise require 3 people. Before cutting spend, you need to understand the spend’s impact on the business, and whether you can redirect that spend to a better use.</p><p>Not all spend types are created equally when cutting costs. If you have already signed a contract, you may pay for a tool even if you shut it off. As such, when cutting spend, it is important to ask ‘can I repurpose the money I save’? Similarly, software tools, and headcount budgets are often determined separately. Shutting down a tool won’t let you hire a new employee, nor will layoffs let you buy new tools.</p><p>Today, <a href="https://www.armory.io/">Armory</a> is going through a tool consolidation effort. For document collaboration we currently use Slab, Notion, Dropbox Paper, Google Docs and Confluence. Every single one of these costs us additional money, and we can save by consolidating. This doesn’t decrease our ability to execute, and may increase it since we’ll have fewer places to search for documents. Such an initiative is a great place to save money.</p><p>A lot of companies, including Armory, do a percentage of their tool spend through cloud vendors. These contracts often have multi-year commitments in order to get discounted pricing. Cloud marketplaces give you an opportunity to shift already committed technology spend from less valuable tools to more valuable tools. As Armory shuts down unneeded tools, we are repurposing committed marketplace spend to cover new tools. This is also why Armory added our <a href="https://aws.amazon.com/marketplace/pp/prodview-uryuhznzfe5po">Continuous Deployment-as-a-Service offering to the AWS Marketplace</a>.</p><p>Your most valuable tool at this time is a tool that can improve your business’s efficiency. This includes both tools to understand your spend, and tools that automate tasks so you can do more with less. Automation and CD tools both fit this bill.</p><h3>What to Automate First to Accelerate Technology Cost Savings?</h3><p>It depends. Do you currently know where your organization is spending its time? <a href="https://devm.io/testing/time-estimation-for-software-testing-128078">35 to 50% of a distributed application’s development</a> time often goes to manual testing and deployment processes. In many organizations a portion of this spend is unique to their company and software (e.g. product-specific test automation). However frequently a large percentage is manual processes or developing home-grown tooling that could be replaced with something off-the-shelf.</p><p>If you do not know where you are spending your time, start by adding high-level automation of your overall SDLC. A lot of teams commit code, and automatically run unit tests. Often the code then sits, waiting for manual processes. Perhaps you have a QA engineer manually testing the code. Perhaps you have an infosec org who runs a security scanner before a monthly release. These are the processes you need to identify. Once a developer has merged their code back to trunk, what still needs to happen before it reaches production?</p><p>Initially, don’t worry about automating every step. Worry about automating the overall process flow for promoting this software all the way to production. Any time you identify a manual process that is not automated, put a manual approval in your overall automation. This will allow you to both identify and measure the performance of the manual steps you need to automate.</p><h3>Manual Step Types in Your Software Release Process</h3><p>Once your overall software promotion flow is automated, and can measure the manual steps along the way. You now need to decide what to do about each step. Many of these steps will be quality controls — they decrease the risk of releasing code. Their goal is to ensure that your customers remain happy. Many exist because of one bad code release that happened many years ago. Some of these steps may not matter anymore at all.</p><p>To determine if a step still matters, ask what the impact of that step is. Ask when the last time was that this step identified a critical issue. I once met n engineering department spending almost half its time on a single process… When we asked whether that process had found any bugs recently, the answer shocked me. The last critical bug it identified was two years prior. They didn’t automate that process, they shut it down, and redirected staff to running or automating other processes. Now that you know what your processes are, ask yourself if they are worth keeping around at all. If you lack the staff to automate, these steps are where you can find your first RTB technology cost savings. This first savings will let you increase your CTB spend to make further improvements.</p><p>Now that all your steps matter, your next question is what step is most worth automating.</p><h3>Prioritizing Steps for Automation</h3><p>I know a few reasons to automate one step before the others:</p><h4>1) The step only a few people can perform.</h4><p>If only few people can perform the step because it is difficult or error prone, you should automate it. There are two reasons for this. Firstly, if the individual running that step leaves, your ability to deliver software may break if it is not automated.. Secondly, such steps may be done by your most talented and capable staff. These are sometimes the staff you most need in order to build automation.</p><h4>2) The highly repetitive step that that is taking the most manpower.</h4><p>You are automating these steps so that you can free up resources to further improve your businesses operations. You likely have a few manual processes that eat up significantly more hours than your other processes. Automating these can free up significant labor in order to redirect to further improving your operations. Additionally, if the process is currently highly repetitive, this can make the automation effort pay off faster.</p><h4>3) The step is slowing down the process the most.</h4><p>The cost of a bug found after release is <a href="https://www.celerity.com/insights/the-true-cost-of-a-software-bug">&gt;4x higher to fix than if it had been uncovered during initial development.</a> This means that simply finding bugs sooner can create technology cost savings. Context switches lower productivity, and finding issues quickly will allow them to be resolved with fewer context switches. After you have automated process types 1 and 2 far enough that you no longer need to worry about what happens when someone leaves, automate these steps. When times are good, these are the first thing to automate, when a recession looms, optimize the other two categories first.</p><h3>Examples From My Career, and How CD Concepts Help Create Technology Cost Savings:</h3><h4>Blue/Green Deployments</h4><p>At a prior company I had a software product that took a day to start when some customers upgraded. To minimize customer downtime, we manually stood up two copies of the software in parallel with that customer’s configuration. Once the new version started, we then redirect a load balancer to send traffic to the new version. Only once we were sure the customer was happy with the new version did we shut down the old version. Relatively few staff members had the skills to perform this procedure manually, making it an optimization of type one. It also was a significant bottleneck in releasing code to customers, making it a process of class 3.</p><p>Many continuous deployment tools on the market provide out-of-the-box automation for a blue/green deployment strategy. Blue/Green deployment is an off-the-shelf way of implementing the above process. We replaced the high-risk manual process that few individuals could do with an automated process that anyone can trigger. This creates an RTB technology cost savings and allows you to redirect manpower to further changing your business.</p><h4>Product-specific automated tests:</h4><p>I once saw a technology department that was spending almost half its engineering organization’s time on a single process. They deployed copies of customer configurations on an old and new software version, and then manually reviewed every report. For each report they would manually compare the numbers, looking for differences.</p><p>There was already a customer agnostic API for getting a list of all the reports, and downloading each report’s data….. This department wrote a tool that could be perform a diff between two versions of the software. This tool was more accurate, and it was faster, freeing up time to further automate.</p><p>The next thing automated in this process was deployment. Running this tool required standing up two environments with copies of the customer’s configuration. This was still taking a large amount of time. The solution? Add a test suite that ran after the development team’s code reached main. Have this suite automatically deploy a copy of each customer, and run the validation tool on it. This increased the organizations velocity while freeing up staff to work on further improvements. It also created technology cost savings by decreasing the overhead around labor, compute, and communication when releasing new software versions.</p><p>Many Continuous deployment software packages can help you automate flows such as this. For example, web hooks can trigger database copy scripts before deployment, or run test validation after deployment. If the validation succeeds your software release process can automatically move onto its next stage.</p><h4>Security Scanners:</h4><p>Many companies have compliance rules that require tools such as security scanners to be run before they deploy to production. I’ve also seen gatekeeping around such processes — a dedicated organization that must run the scanner against a dedicated environment. Before the scanner is run, someone else manually deploys a new code version to the scanning environment.</p><p>These are an opportunity for continuous deployment automation: Automatically deploy the security scanning environment, and run the security scanner. If the scanner passes, move on to the next step, otherwise cancel deployment to downstream environments.</p><h3>How Continuous Deployment can Help You Create Cloud Technology Cost Savings:</h3><p>When adopting tools to provide visibility into cloud spend a frequent challenge is understanding who is responsible for what infrastructure. You may know what namespace is causing most of your spend, but you need to identify who the owns it. Many cd tools provide automated tagging of the infrastructure they deploy. For example, all Armory products add annotations tracking what application deployed a given piece of configuration. When you know what app deployed it, you can easily check which users can deploy that application. Suddenly you have a standard way to find the responsible party! This can help you get technology cost savings &amp; optimization advice back to the teams that can action it.</p><p>In recent years there are also software packages like <a href="https://www.kubecost.com/">KubeCost</a> that make recommendations on optimizing your cloud spend. A robust Continuous Deployment pipeline can <a href="https://www.armory.io/blog/continuous-cost-optimization-for-kubernetes/">automatically deploy these recommendations</a>, while <a href="https://www.armory.io/blog/continuous-cost-optimization-for-kubernetes/">validating that your service remains healthy following the change</a>.</p><h3>Quick Recap:</h3><p>We’ve discussed ways to manage your technology spend during these tough economic times. You’ve learned how to improve your company while your budget shrinks, so you can keep up with your competitors. We’ve discussed making the business case for continuous deployment, and how CD helps your organization create technology cost savings. Is the recession increasing the risk on your business? Don’t wait, start automating your software deployment before it is too late. If you need help along your continuous deployment and automation journey <a href="https://www.armory.io/contact-us/">let us know</a>, we’re here to help.</p><h3>Don’t miss our related blogs:</h3><p>Armory has posted several other blogs related to continuous deployment and technology cost savings. Don’t miss them:</p><ul><li><a href="https://www.armory.io/blog/continuous-cost-optimization-for-kubernetes/">Continuous Cost Optimization for Kubernetes</a></li><li><a href="https://www.armory.io/blog/deploying-opencost-with-a-functional-ui/">Deploying OpenCost</a></li><li><a href="https://www.armory.io/blog/introducing-opencost-an-open-source-project-for-monitoring-kubernetes-spend/">Introducing OpenCost</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d23deabb92c3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/how-continuous-deployment-creates-technology-cost-savings-d23deabb92c3">How Continuous Deployment Creates Technology Cost Savings</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Deploying OpenCost with a functional UI]]></title>
            <link>https://medium.com/armory/deploying-opencost-with-a-functional-ui-a5696975e24f?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/a5696975e24f</guid>
            <category><![CDATA[it-finance]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[deployment]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Fri, 14 Oct 2022 17:26:52 GMT</pubDate>
            <atom:updated>2022-10-14T17:26:52.619Z</atom:updated>
            <content:encoded><![CDATA[<p>This blog is a reposting of <a href="https://www.armory.io/blog/deploying-opencost-with-a-functional-ui/">Armory’s latest blog</a>, discussing how you can deploy the OpenCost UI. <a href="https://www.armory.io/">Armory</a> is an <a href="https://www.opencost.io/">OpenCost</a> launch partner, so when we saw the community encountering challenges here, I wanted to share the configuration I had that was successfully running the OpenCost UI in my cluster. Learn more below.</p><h3>Introduction</h3><p>On the <a href="https://communityinviter.com/apps/cloud-native/cncf">OpenCost slack</a>, I keep seeing questions from users struggling to get the openCost UI to run in-cluster. While we wait for a Docker image that bundles the UI to become available, I want to share the configuration I use to run the UI within a Kubernetes cluster.</p><p>My configuration is located in <a href="https://github.com/stephenatwell/openCost-deployment-blog">this git repository</a>. This blog documents the configuration, how to use it, and why it works the way it does.</p><h3>Provided Functionality</h3><p>This repository deploys:</p><ol><li>A Prometheus stack that includes the OpenCost scrape configuration</li><li>The OpenCost cost model</li><li>The OpenCost UI</li></ol><p>The example Configuration uses Kustomize in order to both inject a UI container, and to simplify changing configuration variables. Any configuration change to OpenCost’s allocation engine or UI that is done via environment variable can be specified in the kustomization.yml file.</p><p>This repository can be used standalone and applied via kubectl, or it can be deployed with Armory <a href="https://www.armory.io/products/continuous-deployment-as-a-service/">CD-as-a-Service</a>. When using CD-as–a-Service, it uses prometheus queries during upgrade to validate that the OpenCost Prometheus queries function. The intention of this validation is to decrease the risk of upgrading to the latest version.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*n8zvAnB6DkM14Kru" /></figure><p>There is currently no docker image that contains the UI. The provided configuration deploys it by using <a href="https://hub.docker.com/r/timbru31/node-alpine-git/">a Docker image that contains git and npm</a>. This image is configured to checkout the OpenCost repo and start the UI automatically. This is suboptimal since it is always grabbing the latest UI from git every-time the pod starts. Once <a href="https://github.com/opencost/opencost/pull/1411">a Docker image is available that contains the UI</a>, I would recommend switching to it instead so that the pod is immutably defined.</p><h3>Connecting to the OpenCost UI after deploying</h3><p>To port forward both the cost model and the UI, run the following commands while connected to the Kubernetes cluster to which you have deployed OpenCost.</p><p>kubectl -n=opencost port-forward service/opencost-ui 1234</p><p>kubectl -n=opencost port-forward service/opencost 9090:9003</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/795/0*BxeOyuSxTPhSeTVH" /></figure><h3>Exposing the UI via Ingress or a Load Balancer</h3><p>Currently the OpenCost UI does not support being exposed via an Ingress or a Load Balancer. This is because it is hard coded to reference ‘Localhost’ for the URL that the user’s web browser uses to connect to the OpenCost cost Model. Do the following to expose the UI:</p><ol><li>Either create an ingress rule or a load balancer for the <em>opencost</em> service. This will make the backend accessible to be queried externally.</li><li>In the kustomization.yml file, update the BASE_URL configuration to the external URL exposed in step 1.</li><li>Either create an ingress rule or a load balancer for the <em>opencost-ui</em> service. This will make the ui accessible to be queried externally.</li></ol><h3>Deploying using Kubectl</h3><p>To deploy using kubectl, clone the repo, and then in its root run:</p><p>kustomize build --enable-helm . &gt; manifests.yml</p><p>Kubectl apply -f manifests.yml</p><h3>Deploying using Armory CD-as-a-Service</h3><p>Armory adds automated upgrade testing that ensures Prometheus is ingesting OpenCost cost data, and container memory data. It also simplifies deploying OpenCost across large numbers of clusters.</p><p>If you are not already using Armory CD-as-Service:</p><ol><li><a href="https://www.armory.io/products/continuous-deployment-as-a-service/">Sign up for Armory CD-as-a-Service</a></li><li>Connect your Kubernetes cluster using the setup wizard.</li></ol><p>Now connect the prometheus deployment that this setup will create:</p><ol><li>In the CD-as-a-Service UI go to configuration\integrations</li><li>Click ‘new integration’</li><li>Configure it with:</li></ol><ul><li>Type = Prometheus</li><li>Name = opencost-Prometheus</li><li>Base URL = <a href="http://my-prometheus-server.opencost.svc/">http://my-prometheus-server.opencost.svc</a></li><li>Remote Network Agent = (the one you specified in step 2)</li></ul><p>CD-as-a-Service can deploy either from its <a href="https://docs.armory.io/cd-as-a-service/setup/cli/">CLI</a>, or using <a href="https://github.com/marketplace/actions/armory-continuous-deployment-as-a-service">its Github Action</a>. Instructions for both follow. For either path, start by forking <a href="https://github.com/stephenatwell/openCost-deployment-blog">this git repository</a>. After forking, open the deploy.yml file, and replace the ‘account’ name on both environments with the name that you specified in step 2 above.</p><h3>If you are using Github Actions</h3><p>To deploy using Github Actions you must <a href="https://docs.armory.io/cd-as-a-service/tasks/iam/client-creds/">create a client credential and add it to a Github secret</a>.</p><ol><li>In the Armory UI:</li><li>Go to ‘Configuration\Client Credentials’</li><li>Click ‘create credential’ and give it a name.</li><li>Copy the clientID and Secret</li><li>In the Github UI, open your forked repository and go to:</li><li>Settings</li><li>Secrets</li><li>Actions</li><li>Click ‘New Repository Secret’, name it ‘CDAAS_CLIENT_ID’ and give it the value of the ‘clientID’ that you copied in step 1.</li><li>Click ‘New Repository Secret’, name it ‘CDAAS_CLIENT_SECRET’ and give it the value of the secret that you copied in step 1.</li><li>In the github UI, enable workflows on your repository.</li><li>Make any change to the repository to deploy opencost.</li></ol><h3>If you are using Armory’s CLI</h3><p>The cli can be used to deploy using an interactive login, or called from your CI system using client credentials. Here is how you deploy with an interactive login:</p><ol><li>Install the CLI by running curl -sL go.armory.io/get-cli | bash</li><li>Run armory login to login through the UI</li><li>Checkout your forked git repo, and cd into it</li><li>Run ./deploy.sh to deploy. This shell script will build the kustomize files, then use the cli to deploy.</li></ol><h3>Adding Additional Clusters</h3><p>If you want this configuration to deploy to multiple Kubernetes clusters, copy the environments, and give the copies a new name and update the account. If one of your clusters is a staging cluster that should run before the others you can add a dependsOn constraint to the clusters that depend on it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*S4aMcXNLOLRQsO7S" /></figure><p>Example: add a staging cluster, and making production depend on it</p><p>targets:<br> #where to deploy code, and in what order. Specifies accounts and namespaces for each application.<br> production:<br> account: demo-prod-west-cluster<br> namespace: opencost<br> strategy: opencost<br> constraints:<br> dependsOn: [&quot;staging&quot;]<br> staging: #an example new environment<br> account: staging<br> namespace: opencost<br> strategy: opencost</p><p>Now when you deploy every cluster will get the update, and run the query validation logic.</p><h3>Using your existing Prometheus</h3><p>If want to use your existing prometheus, make the following changes to your kustomization.yml:</p><ol><li>comment out the helm charts section</li><li>Comment out the ‘prometheus-overrides’ line</li><li>Update the PROMETHEUS_SERVER_ENDPOINT url to the url of your prometheus server.</li></ol><p>You must also ensure you have added <a href="https://raw.githubusercontent.com/opencost/opencost/develop/kubernetes/prometheus/extraScrapeConfigs.yaml">the OpenCost scrape configuration</a> to your prometheus server.</p><h3>Recap</h3><p>We’ve covered how you can deploy OpenCost to either one or many Kubernetes clusters from a common configuration, and discussed ways to validate its health during deployment, and covered how to get the UI working. We’ve also provided a kustomize-based configuration that allows you to continue inheriting OpenCost’s default configuration while overriding just the portions that you need to change.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5696975e24f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/deploying-opencost-with-a-functional-ui-a5696975e24f">Deploying OpenCost with a functional UI</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Streamline Advanced Kubernetes Deployments from GitHub Actions with New Armory Service]]></title>
            <link>https://medium.com/armory/streamline-advanced-kubernetes-deployments-from-github-actions-with-new-armory-service-d74e5f4b8520?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/d74e5f4b8520</guid>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Fri, 23 Sep 2022 16:24:19 GMT</pubDate>
            <atom:updated>2022-09-26T16:56:41.847Z</atom:updated>
            <content:encoded><![CDATA[<p>Today, Armory is excited to announce the availability of the GitHub Action for Armory Continuous Deployment-as-a-Service. GitHub is where developers shape the future of software. After a developer writes and tests their code in GitHub, it must be deployed. <a href="https://github.com/marketplace/actions/armory-continuous-deployment-as-a-service">Armory’s GitHub Action for Continuous Deployment-as-a-Service</a> extends the best-in-class deployment capabilities to Kubernetes.</p><p>CD-as-a-Service enables declarative continuous deployment, with a GitOps experience, and advanced deployment strategies to mitigate the risk of frequent deployments to production.</p><p>By orchestrating and automating deployment across all environments, CD-as-a-Service removes demands on developers and reduces the risk of service disruptions due to change failures. CD-as-a-Service requires no migration; it seamlessly plugs into your existing GitHub SDLC.</p><p>This minimizes risks by providing deployment flexibility and limiting the number of users that are exposed to potential bad changes, leading to a better customer experience. Let your developers focus on building great code, not deploying it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*shaV4c1k4n2RhVGC.png" /></figure><p>Deploying your application with this GitHub Action is easy, just <a href="https://www.armory.io/products/continuous-deployment-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub">sign up</a> for CD-as-a-Service, and <a href="https://docs.armory.io/cd-as-a-service/setup/get-started/#connect-your-kubernetes-cluster?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub">connect your cluster</a>. Then define how your application should deploy (e.g. a <a href="https://docs.armory.io/cd-as-a-service/setup/cli/#manually-deploy-apps-using-the-cli?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub">canary</a> or <a href="https://docs.armory.io/cd-as-a-service/setup/blue-green/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub">blue/green</a> strategy), and add it to your <a href="https://docs.armory.io/cd-as-a-service/setup/gh-action/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub">GitHub Actions workflow</a>.</p><p>Once you are deploying, you can also leverage<a href="https://docs.armory.io/cd-as-a-service/tutorials/external-automation/webhook-github/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub"> Armory webhooks to orchestrate GitHub Actions based integration tests</a> in your staging environments after they deploy.</p><p>Want to know more? Try it out by <a href="https://www.armory.io/products/continuous-deployment-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories">signing up for free</a>, <a href="https://github.com/marketplace/actions/armory-continuous-deployment-as-a-service">review our marketplace listing</a> or<a href="https://www.youtube.com/watch?v=r29UCKMXEi4?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=CD_as_a_Service_GitHub"> watch a demo</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d74e5f4b8520" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/streamline-advanced-kubernetes-deployments-from-github-actions-with-new-armory-service-d74e5f4b8520">Streamline Advanced Kubernetes Deployments from GitHub Actions with New Armory Service</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Continuous Deployment-as-a-Service, Continuous Update | September 2022]]></title>
            <link>https://medium.com/armory/continuous-deployment-as-a-service-continuous-update-september-2022-c39149d16c89?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/c39149d16c89</guid>
            <category><![CDATA[tools]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Wed, 14 Sep 2022 15:54:19 GMT</pubDate>
            <atom:updated>2022-09-14T15:54:19.493Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction:</h3><p>This summer we launched Continuous Deployment-as-a-Service (learn all about it <a href="https://www.prnewswire.com/news-releases/armory-launches-continuous-deployment-as-a-service-product-301569172.html">here</a>), and we’re starting this blog to keep you up to date on all of the updates and news around this solution. At Armory, we want to make sure you have all of the tools you need to be successful when deploying your code. Armory will handle your Continuous Deployment so you can focus on what you do best — providing innovation and the best possible customer experience to your customers.</p><p>Below, you’ll find the latest CD-as-a-Service news: our latest updates, upcoming events, and what we’re working on next. Haven’t tried out CD-as-a-Service yet? Click <a href="https://go.armory.io/signup">here</a> to get started, it’s free!</p><h3>New Releases &amp; Enhancements:</h3><ul><li><strong>Allocate Resources Efficiently with <em>Support for Horizontal Pod Autoscalers (HPA)</em>:</strong> CD-as-a-Service adds support for a Horizontal Pod Autoscaler (HPA) during deployments. You configure the HPA(s) in your application’s manifest file. CD-as-a-Service deploys any HPA tied to a Kubernetes Deployment object and enables autoscaling after the deployment to your environment finishes.</li><li><strong>Save time with <em>Redeploying a Replicaset on any change</em>:</strong> Many deployment solutions only apply the deployment logic for certain changes, such as a change in the application image version. Other changes, such as changes to configuration maps may not follow the same strategy and validation. CD-as-a-Service now follows the same deployment strategy for any change, to any Kubernetes object, ensuring all changes are validated and applied safely. This means, for example, that when deploying just a change to a configuration map, a new ReplicaSet will be created, and validated, just like any other change.</li><li><strong>Speed up your deployments with<em> Support for Traffic Management with Service Mesh Interface (SMI)</em>:</strong> It is now possible to have fine-grained traffic management during canary deployments using Service Mesh Interface (SMI). This should allow you to send as little as 1% of traffic to the canary version of your application to verify the impact of a change. Here is the link for the documentation for this new feature as well as a full blog post <a href="https://www.armory.io/blog/progressive-canary-with-armory-cd-as-a-service/">here</a>!</li><li><strong>Increase Reliability and save time with</strong> <strong><em>Automated Webhook-based Approvals</em>: </strong>We knew it was important to enable users to easily hook their existing automated process into the Armory Deployments pipeline. Specifically, we had three primary use cases in mind:</li><li><strong>For application developers</strong>, it enables automatically running their integration tests once the staging environment deploys, and only requires updates to the production environment if the integration tests pass.</li><li><strong>For an application test suite</strong>, there is a selenium test that checks basic functionality of your application that you can run during canary deployment as traffic increases, and rollback in the event of failure..</li><li><strong>InfoSec engineers </strong>can run security scanners against applications in a staging environment, and only promote application changes to production if the scanner detects no new issues.</li></ul><h3>Horizontal Pod Autoscaler: (Read the HPA blog <a href="https://www.armory.io/blog/horizontal-pod-autoscaling-during-kubernetes-deployments/">here</a>!)</h3><ul><li><strong>Problem: Deployment Solutions need to take into account load and current HPA state when deploying in order to ensure maximum uptime and efficient use of resources. </strong>Prior to this feature that wasn’t possible. Historically, CD-as-a-service hasn’t supported applications that use a horizontal pod autoscaler. (HPAs are used to dynamically change the amount of resources dedicated to an application based on that application’s current load).</li><li><strong>Solution: </strong>When deploying CD-as-a-Service now looks at the amount of resources HPA has scaled for your application and makes sure that both the old and new versions are running at that current scale. Now, you can do a Blue/Green Deployment, you have equal allocation to servers when deploying. If your current version needs ten servers, CD-as-a-Service knows the new one will too, and allocates resources accordingly.</li><li><strong>Who it Benefits: </strong>Infrastructure Operations, Platform Engineers, Site Reliability Engineers, IT Operations</li><li><strong>How it works:</strong></li></ul><p>Step 1: Before starting a deployment to an environment, CD-as-a-Service takes note of the scale that your application is currently running and maintains this scale until the deployment to the environment is finished.</p><ul><li>The Details: Because CD-as-a-Service knows the scale right before the deployment starts, it can alter deployment strategies in a way that does not cause degraded service. For example, when you are using a Blue/Green strategy, the next version of the application is scaled up to meet the current traffic load before traffic is moved over to the new version. Once the traffic is cut over to the new version, your users would not experience interruptions or degraded service. Additionally, this approach ensures reliability and speed when rolling back — your rollbacks don’t have to scale up to support the required traffic.</li><li>Step 2: CD-as-a-Service then disables the HPA for your application and executes your deployment strategy.</li><li>The Details: By disabling HPA during the deployment strategy, we can ensure that HPA does not interfere with the strategy. For instance, in case of automated analysis results, if the new version has a memory leak the HPA could scale up and thwart the threshold based queries. Or during<a href="https://www.armory.io/blog/progressive-canary-with-armory-cd-as-a-service/"> pod-ratio canary deployments</a>, HPA could scale down pods and could force more users into the canary version of the application.</li><li>Step 3: After successfully deploying the new version of the application, CD-as-a-Service then enables HPA for the new version of the application.</li><li>The Details: CD-as-a-Service deploys every change you make, even changes to the HPA. That means as you refine your HPA configuration to the application’s needs, you can run automated performance tests in staging environments before ever deploying new HPA configurations to production.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*eIw_-mkUIPrPphWz" /></figure><h3>Redeploying a Replicaset</h3><ul><li><strong>Problem: </strong>When a Kubernetes resource like configMap or secret is updated, often those changes are not reflected immediately. For these changes to take effect, the relevant pods need to be restarted. This process is usually manual, or there is a homegrown automation that tries to achieve that. More than anything, it forces you to know the intricacies of Kubernetes and know exactly which resources need pod restarts and how can those pods restarted safely without causing interruptions.</li><li><strong>Solution: </strong>CD-as-a-Service follows the prescribed deployment strategy and deploys a new ReplicaSet anytime there is a deployment. Deploying a new ReplicaSet makes sure that your changes are picked up by the new pods. CD-as-a-Services ensures reliability by executing on the deployment strategy to identify potential issues early on and not causing interruptions for end users.</li><li><strong>Who it Benefits: </strong>Application Developers, Infrastructure Operations, Platform Engineers, Site Reliability Engineers, IT Operations, and anyone who is not a Kubernetes expert.</li><li><strong>How it works:</strong> CD-as-a-Service will deploy a new ReplicaSet for any change that occurs in the application, even if the change is one of the Kubernetes resources that is deployed. The deployment will still follow the strategy defined for the environment. For instance, if your prod environment uses Blue/Green strategy to deploy, CD-as-a-Service will use the Blue/Green strategy to deploy a new ReplicaSet and deploy the resource changes. If any automated tests indicate an error, then the deployment can be immediately rolled back.</li><li><strong>How to get it: </strong>There is no special configuration needed to access this behavior. Anytime you deploy a change, be it a new version of the image or just changing Kubernetes resources, a new ReplicaSet will be spawned so that all the changes are deployed reliably.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rHAS6um0JBHiG_uR" /></figure><h3>Support for Traffic Management with Service Mesh Interface (SMI)</h3><ul><li><strong>Problem: </strong>Historically, doing blue/green or canary deployment has required manually updating routing rules to the newly deployed version. Creating a new stack and updating the routing rules is complicated, error-prone, and complex to automate.</li></ul><p>Today, progressive deployments scales up the new version slowly, and routes a percentage of new traffic based on the percentage of pods running the old version and the new version. This requires us to scale down the old version as we scale up the new version, which prevents instantaneous rollback if an issue is discovered.</p><ul><li><strong>Solution: </strong>Allow traffic to be routed by updating traffic routing rules via any SMI-compliant service mesh, instead of by stopping and starting pods.</li><li><strong>Who it Benefits: </strong>Platform engineers</li><li><strong>How it works: </strong>CD-as-a-Service creates a new service for the old and new application version, and creates an SMI rule to route traffic from your specified service to the dynamically created versions with the appropriate traffic split.</li></ul><p><strong>Update your deployment configuration to specify the </strong><a href="https://docs.armory.io/cd-as-a-service/tasks/deploy/traffic-management/"><strong>SMI service to route traffic</strong></a><strong> for.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3kJPaLMOGw8Q8x0H" /></figure><h3>Automated Webhook-based Approvals</h3><ul><li><strong>Problem: </strong>Adopting a new CD tool often means changing your existing test and security automation, or manually triggering it and issuing manual approvals. Ideally, production deployment should only occur once all integration tests pass on the staging environment. Oftentimes, this process of running smoke tests and promoting a deployment to production is manual and time-consuming.</li><li><strong>Solution: </strong>Webhook based Approvals gives you the agency to automatically trigger existing automation like smoke tests and security scanners, and use the results of those automated tests and processes to decide if a deployment is fit to be rolled back or proceed further in the pipeline.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1010/0*5qethYDiOfJUm2UQ" /></figure><ul><li><strong>Who Benefits: </strong>Application Developers, Platform Engineers, Performance Engineers, Quality Assurance Engineers, Infosec</li><li><strong>How it works: </strong>Webhooks can be configured at any point in the deployment’s lifecycle. You can run a webhook before deploying to an environment to trigger a database upgrade. Alternatively, you could use a webhook during deployment to check against your logging service to measure rate of errors, or to run smoke tests.</li><li>Within CD-as-a-Service webhooks are simple REST API calls which can be customized. After making an API request, CD-as-a-Service waits for a callback with a success or failure status. If the callback status is successful, the deployment proceeds to the next step. However, if the callback returns failure, then the deployment automatically rolls back and stops deployment to any future environment.</li><li><strong>How to get it: </strong>Webhooks can be configured in the CD-as-a-Service deployment YAML and can be used within a deployment strategy like canary or Blue/Green or be used as an environment specific constraint to trigger before or after deployment. <a href="https://docs.armory.io/cd-as-a-service/tutorials/external-automation/webhook-github/">To get started with webhooks based approvals, check out our docs.</a></li><li><strong>If you are not sure how this benefits you, check out our blog </strong><a href="https://www.armory.io/blog/using-your-existing-automation-in-your-deployment-pipeline/"><strong>post</strong></a><strong> all about this feature.</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R296d_A7S-njlqnk" /></figure><h3>Armory in the News</h3><p>For all things newsworthy, check out the coverage of our new 2.28 product release here:</p><ul><li><a href="https://www.dbta.com/Editorial/News-Flashes/Armorys-228-Product-Release-Continues-to-Accommodate-Company-Growth-and-Scale-154254.aspx">Armory’s 2.28 Product Release Continues to Accommodate Company Growth and Scale</a></li><li><a href="https://www.helpnetsecurity.com/2022/08/04/armory-cd-self-hosted-and-managed-2-28/">Armory CD Self-Hosted and Managed 2.28 aids DevOps to deploy software at any scale</a></li><li><a href="https://vmblog.com/archive/2022/08/03/armory-s-new-continuous-deployment-self-hosted-and-managed-2-28-empowers-devops-growth-and-scale.aspx#.YvGQM-zMIpt">Armory’s New Continuous Deployment Self-Hosted and Managed 2.28 Empowers DevOps Growth and Scale</a> — VM blog</li><li><a href="https://www.prnewswire.com/news-releases/armorys-new-continuous-deployment-self-hosted-and-managed-2-28-empowers-devops-growth-and-scale-301598802.html?tc=eml_cleartime">Armory’s New Continuous Deployment Self-Hosted and Managed 2.28 Empowers DevOps Growth and Scale</a> — PR Newswire</li></ul><h3>Hope to see you there — Upcoming Events</h3><p>We look forward to seeing you at these upcoming webinars and virtual events.</p><p><strong>KubeCon + CloudNativeCon North America</strong> — October 24–28, Detroit, <a href="https://events.linuxfoundation.org/kubecon-cloudnativecon-north-america/register/">Registration and Additional Info Here</a></p><ul><li>This is a hybrid event taking place both in person and with a virtual component from October 24–28. Pre-event programming will take place on October 24–25 and the main conference will be on October 26–28. In person AND online content will be showcased over five days, including keynotes, conference sessions across 10+ tracks, tutorials, sponsor booths, and networking opportunities..</li></ul><h3>On the Horizon:</h3><ul><li><strong>Enterprise Tier: RBAC</strong> — you will be able to control who does what with Armory CD-as-a-Service. Unlike some solutions in the market, it allows you to control not just who can do what, but also who can do what where. For example, who can deploy what applications to which clusters in which namespaces.</li><li><strong>Notifications: </strong>As an Application Developer, I have no way of knowing when my deployment is ready for me to review it and issue any needed manual approvals to continue scaling. We are adding the ability to subscribe to notifications about your deployment pipeline. Notifications can be sent to slack, or your custom webhook.</li></ul><p><em>Follow us on </em><a href="https://www.linkedin.com/company/armory.io/mycompany/"><em>LinkedIn</em></a></p><p><em>Follow us on </em><a href="https://twitter.com/CloudArmory"><em>Twitter</em></a><em> </em>Write your code, package your artifacts, declare your application targets, and commit — Armory Continuous Deployment-as-a-Service will take care of the rest. Get started <a href="https://auth.cloud.armory.io/login?state=hKFo2SBsV0pMWVV6eHdINmNpWml1dmtudXRGVTZCTHRUbVdtQqFupWxvZ2luo3RpZNkgMUJiUTd2aDAzN0laY18weV82MmRJVFVBaWVGWlE5Rk6jY2lk2SB3OEFXUU1HMVRleFEzcUUzU2xLZURKTzNuVVRrTjFmUA&amp;client=w8AWQMG1TexQ3qE3SlKeDJO3nUTkN1fP&amp;protocol=oauth2&amp;audience=https%3A%2F%2Fapi.cloud.armory.io&amp;scope=openid%20profile%20email&amp;instanceRegistration=false&amp;redirect_uri=https%3A%2F%2Fconsole.cloud.armory.io%2Flogin%2Fcallback&amp;screen_hint=signup&amp;response_type=code&amp;response_mode=query&amp;nonce=WVl5Zkk5Y292ZFdrR0otdE82MDYxb0xsUGZGZFBrSUJySTJOT1B1UDdKYQ%3D%3D&amp;code_challenge=RxsiLEqF8-Bw5PBk3WndqlbDPEhpY8stz_VmwVMyRlI&amp;code_challenge_method=S256&amp;auth0Client=eyJuYW1lIjoiYXV0aDAtcmVhY3QiLCJ2ZXJzaW9uIjoiMS44LjAifQ%3D%3D">here</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c39149d16c89" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/continuous-deployment-as-a-service-continuous-update-september-2022-c39149d16c89">Continuous Deployment-as-a-Service, Continuous Update | September 2022</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Leveraging Locust.io Performance Tests in your Deployment Pipeline]]></title>
            <link>https://medium.com/armory/leveraging-locust-io-performance-tests-in-your-deployment-pipeline-c53fc64a1f52?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/c53fc64a1f52</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[performance-testing]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Thu, 18 Aug 2022 13:40:27 GMT</pubDate>
            <atom:updated>2022-08-22T18:27:02.256Z</atom:updated>
            <content:encoded><![CDATA[<p>I recently read <a href="https://medium.com/teamsnap-engineering/load-testing-a-service-with-20-000-requests-per-second-with-locust-helm-and-kustomize-ea9bea02ae28">a blog</a> on how to load test an application using <a href="https://locust.io/">Locust</a>, <a href="https://helm.sh/">Helm</a>, and <a href="https://kustomize.io/">Kustomize</a>. I wanted to add Locust performance testing into my standard deployment pipeline so that I can ensure that performance tests pass before any application code is released to production. This blog discusses how I took the Locust configuration from that blog and incorporated it into my existing continuous deployment pipeline by leveraging <a href="https://www.armory.io/products/continuous-deployment-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=managed_product_page">Armory Continuous Deployment-as-a-Service</a> and <a href="https://github.com/features/actions">Github Actions</a>.</p><p>I started with an existing application that deployed to 6 environments distributed over 3 Kubernetes clusters, and added a 7th environment — a new performance testing environment. Within the performance testing environment, I deployed <a href="https://locust.io/">Locust</a> alongside my application using <a href="https://medium.com/teamsnap-engineering/load-testing-a-service-with-20-000-requests-per-second-with-locust-helm-and-kustomize-ea9bea02ae28">the blog’s configuration</a> of the Locust <a href="https://github.com/deliveryhero/helm-charts/tree/master/stable/locust">helm chart</a>.</p><h3><strong>Merging the Configurations</strong></h3><h4><em>The Kustomize Configuration</em></h4><p>I started with the configuration from <a href="https://medium.com/teamsnap-engineering/load-testing-a-service-with-20-000-requests-per-second-with-locust-helm-and-kustomize-ea9bea02ae28">the other blog</a> and copied it into my application’s git repository. I made a couple of tweaks from this starting point to fit my needs.</p><p>The initial configuration leveraged Kustomize’s ability to add a suffix on configuration maps. The suffix ensured Kubernetes would spin up new worker pods on configuration changes. Because I am deploying through Armory CD-as-a-Service, I do not need the suffix because it always creates new pods when deploying. I disabled the suffix by adding the following two lines to the Kustomize file:</p><pre><strong>generatorOptions:<br>   disableNameSuffixHash: true</strong></pre><p>I also disabled the Horizontal Pod Autoscaler so that I would only have a single worker pod because my cluster is very small:</p><pre>helmCharts:<br>- name: locust<br>  valuesInline:<br>    worker: <br>      hpa:<br>        enabled: <strong>false</strong></pre><p>After these changes, I have the following Kustomize configuration:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/573683d627d2f9df1ffb04cbd3c3fd84/href">https://medium.com/media/573683d627d2f9df1ffb04cbd3c3fd84/href</a></iframe><h4><em>The Github Actions Workflow Configuration</em></h4><p>I trigger my deployment pipeline from Github Actions. I updated my Github Actions workflow to generate manifests from the Kustomize file before starting my deployment. Manifest generation tools like <a href="https://kustomize.io/">Kustomize</a> and <a href="https://helm.sh/">helm</a> generate Kubernetes manifests to deploy. These tools can either directly deploy the manifests, or write them to a file. My workflow builds the Kustomize file, and writes the generated manifests to a temporary file. In a later step we will pass this file to CD-as-a-Service for deployment as part of my larger pipeline.</p><pre><strong>- name: installHelm<br>  uses: yokawasa/action-setup-kube-tools@v0.7.1<br>  with:<br>          helm: &#39;3.9.2&#39;<br>          kustomize: &#39;4.5.7&#39;<br>- name: buildLocust<br>  run: kustomize build --enable-helm thirdParty/locust &gt; thirdParty/locust/generatedManifest.yml</strong></pre><h4><em>The CD-as-a-Service Configuration</em></h4><p>I then updated my existing CD-as-a-Service deployment configuration to add a new ‘performance testing’ environment called <strong>perf</strong>. This environment adds a constraint to require a manual approval. Downstream environments will not deploy until after someone approves this. Instead of approving, I can cancel deployment if the tests fail.</p><pre>targets:<br>  <strong>perf:<br>    account: demo-staging-cluster<br>    namespace: borealis-perftest<br>    # just deploy with a rolling update, its staging.<br>    strategy: rolling<br>    constraints:<br>      dependsOn: [&quot;dev&quot;]<br>      afterDeployment:<br>      - pause:<br>          untilApproved: true</strong></pre><p>I then added the manifest generated by Kustomize, and specified that it should only be deployed to the new environment.</p><pre>manifests:<br><strong>- path: thirdparty/locust/generatedManifest.yml<br>  targets: [perf]</strong></pre><p>Finally, I updated my production environments to only deploy if the performance testing is successful.</p><pre>targets:<br>  prod-eu:<br>    constraints:<br>      dependsOn: [ &quot;staging&quot;,<strong>&quot;perf&quot;</strong>,&quot;infosec&quot; ]<br>  prod-east:<br>    constraints:<br>      dependsOn: [ &quot;staging&quot;,<strong>&quot;perf&quot;</strong>,&quot;infosec&quot; ]<br>  prod-west:<br>    constraints:<br>      dependsOn: [ &quot;staging&quot;,<strong>&quot;perf&quot;</strong>,&quot;infosec&quot; ]</pre><h3><strong>Running my Configuration</strong></h3><p>Now when I commit, my development environment deploys. After it finishes, my 3 staging environments deploy. My integration tests and security scanners are automatically triggered via webhook, and my performance testing environment redeploys Locust. I am not yet automatically starting the Locust test, nor checking its results. My deployment waits for me to run my performance test, and either approve the results or cancel deployment to production. I find a manual approval in my otherwise automated deployment pipeline is an easy way to get a new test running before every code deploy even before the test is fully automated. This intermediate step already ensures that code only reaches the production environments if the performance tests pass.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/993/1*8hUNysyjYTkwMLeudHzRlA.png" /><figcaption>My integration tests and security scanners passed, my performance tests are waiting for a manual review</figcaption></figure><h3><strong>Next Steps</strong></h3><p>This performance test environment offers two additional opportunities: full automation, and analysis of application metrics outside of Locust.</p><p>For full automation, Locust supports <a href="https://docs.locust.io/en/1.3.0/running-locust-without-web-ui.html">a headless mode</a>, and has an <a href="https://docs.locust.io/en/1.3.0/api.html#">API</a>. The headless mode allows Locust to automatically start a performance test when deployed. I plan to enable this, and then write an automated test that uses Locust’s API to determine whether the test passed. Once I do that, CD-as-a-Service can trigger my test via webhook, and automatically approve or cancel the deployment based off the performance test results.</p><p>CD-as-a-Service also supports analysis of application metrics via <a href="https://www.datadoghq.com/">Datadog</a>, <a href="https://prometheus.io/">Prometheus</a>, and <a href="https://newrelic.com/">New Relic</a>. I can use this to repeatedly compare a metric query to a threshold, and automatically rollback if the threshold is exceeded. My application already leverages this to ensure my metrics remain healthy while deploying to my production environment. Once I automate the performance tests, I will also have CD-as-a-Service check these metrics in my performance testing environment while the tests are running. Then if the performance tests cause any application metric to exceed a threshold that would cause a production rollback, we will never deploy to production in the first place.</p><h3><strong>Trying it for yourself</strong></h3><p>You can <a href="https://www.armory.io/products/continuous-deployment-as-a-service/">signup and start deploying with Armory CD-as-a-Service</a> for free. <a href="https://locust.io/">Locust.io</a> is open source, and also freely available. Both products have demos available on Youtube that you can watch to get an overview of their capabilities: here’s <a href="https://www.youtube.com/watch?v=SOu6hgklQRA">a demo of Locust</a>, and here is <a href="https://www.youtube.com/watch?v=r29UCKMXEi4">a demo of CD-as-a-Service</a>.</p><p>Here is <a href="https://github.com/stephenatwell/locust-blog">a simplified version of my final configuration</a>. It is comprised of:</p><ul><li><a href="https://github.com/stephenatwell/locust-blog/blob/main/deploy.yml">The CD-as-a-Service deployment configuration</a></li><li><a href="https://github.com/stephenatwell/locust-blog/tree/main/thirdParty/locust">The Locust configuration</a></li><li><a href="https://github.com/stephenatwell/locust-blog/blob/main/.github/workflows/trigger-deploy.yml">The GitHub action workflow</a></li></ul><p>This example can run in any cluster. To use it, either give your cluster the name ‘demo-staging-cluster’ when connecting it to <a href="https://www.armory.io/products/continuous-deployment-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=managed_product_page">CD-as-a-Service,</a> or update the name in the deploy.yml to match your cluster’s name. If you wish to use this example from outside of GitHub Actions, run the ‘generateManifest.sh’ script from the Locust configuration directory to build the manifest with Kustomize. Then run the armory cli and pass it the deploy.yml.</p><p>To connect to the Locust UI when your deployment is waiting for the ‘perf’ environment to be approved, run</p><blockquote>kubectl port-forward service/load-test-locust 8089:8089 -n=borealis-perftest</blockquote><p>Then navigate to <a href="http://localhost:8089/">localhost:8089</a> with your web browser.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c53fc64a1f52" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/leveraging-locust-io-performance-tests-in-your-deployment-pipeline-c53fc64a1f52">Leveraging Locust.io Performance Tests in your Deployment Pipeline</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Armory Continuous Deployment Self-Hosted and Managed v2.28]]></title>
            <link>https://medium.com/armory/armory-continuous-deployment-self-hosted-and-managed-v2-28-87562d236db?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/87562d236db</guid>
            <category><![CDATA[spinnaker]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[software-deployment]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[terraform]]></category>
            <dc:creator><![CDATA[Randall Abele]]></dc:creator>
            <pubDate>Wed, 17 Aug 2022 19:39:03 GMT</pubDate>
            <atom:updated>2022-08-17T19:39:04.953Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introducing Armory Continuous Deployment Self-Hosted and Managed version 2.28</h3><p>As I contemplate the current economic situation and observe the industry trend of companies tightening their budgets, I’m reminded of the fact that some of the most amazing products come out of teams who were brave enough to build and innovate during challenging times.</p><p>At the core of Armory is the spirit of community and the power that comes from a group of people who share the feeling that bringing new software into the world will solve big problems and enrich the lives of those around us. It is my belief that teams who stay true to their values in moments of adversity are always rewarded even when facing the challenge of choosing a harder path.</p><p><strong>Expanding the Product Line</strong></p><p>At the beginning of 2022, the Armory team became reinspired by the Spinnaker community and its mission to not only focus on Armory’s new declarative offering, Armory Continuous Deployment-as-a-Service, but also to make a significant investment in both Spinnaker and Armory’s enterprise product, which builds on and contributes to the Spinnaker open source project.</p><p>To accommodate the release of Armory Continuous Deployment-as-a-Service into our growing continuous deployment solutions, we have renamed the self-hosted and managed offerings of Armory Enterprise as follows:</p><ul><li>Armory Enterprise becomes <strong>Armory Continuous Deployment Self-Hosted</strong></li><li>Armory Enterprise Managed becomes <strong>Armory Continuous Deployment Managed</strong></li><li>Armory Agent for Kubernetes becomes <strong>Armory Scale Agent for Spinnaker &amp; Kubernetes</strong></li></ul><h3>Introducing Armory CD Self-Hosted 2.28</h3><p>At Armory, the product and engineering teams have a shared instinct to innovate and deliver new features. After speaking with customers and analyzing the market future of Armory CD Self-Hosted, it was obvious that concentrating on the stability and quality of our product was the next best step. It was important to us to invest in the reliability and performance of that fundamental piece of platform technology, which our customers use as a highway to bring delightful software into the world.</p><p>The guiding principle of stability and quality led us to the release of Armory CD Self-Hosted 2.28.0. This long-term support product release encapsulates all the amazing optimizations, features, and fixes from the Spinnaker community, and raises the enterprise-grade quality bar.</p><p>With this release, we have stayed true to our commitment to capturing increasingly complex use cases to ensure solid releases, as we worked on v2.28!</p><p>Here are some highlights:</p><ol><li>Test Automation Infrastructure: We’ve invested heavily in our test automation infrastructure, capturing and covering new complex use cases that emerge from our elite users as integrated platforms evolve. We also added numerous automated unit, integration, CVE, and end-to-end tests that fire on each commit from OSS Spinnaker or the Armory CD Self-Hosted product features.</li><li>Optimized Release Process: The team optimized the release process to allow for incremental and iterative changes (<em>Short Term Support releases</em>) as needed, culminating in twice annual Long Term Support releases that are backed up by a brilliant group of support and solution engineers who know this product like the back of their hand.</li></ol><p>Ultimately, our validation grows alongside the usage of the product. Engineering teams can be confident when they consume 2.28 and subsequent releases that those releases will work with their specific configurations and use cases. This frees engineers to focus on other tasks and feel confident that the platform can deal with everyone’s favorite “growth and scale” problem.</p><h3>Enhancements</h3><h4>Reduce Operational Risk by Automating Policies on Infrastructure Changes with Terraformer Enhancements</h4><p>We heard from several of our Terraformer users that unintended or non-compliant changes to infrastructure hit them where it hurts: the <a href="https://cloud.google.com/blog/products/devops-sre/using-the-four-keys-to-measure-your-devops-performance">DORA metrics</a>. So we brought a solution that allows you to capture Terraform JSON from a `planfile` and act on it in subsequent stages of your pipeline with an ‘Evaluate Variables’ stage. This allows the pipeline to automatically enforce infrastructure policies and test for quality with every infrastructure change so you reduce any operational risk and increase stability. We also added remote backend support for Terraform Enterprise and Terraform Cloud.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/958/0*JUQ2jEyh0bpjEQAJ" /></figure><p>Check out the <a href="https://docs.armory.io/armory-enterprise/spinnaker-user-guides/terraform-use-integration/">Terraformer documentation</a> for details on these new capabilities.</p><h4>Speed Up Your Time-to-Market and Accelerate your Velocity with Parallel Pipelines</h4><p>The second feature we want to highlight is a clever optimization that was driven by one of our customers unique scale use cases, called <strong>Max Concurrent Pipeline Executions</strong>. This was an open-source Spinnaker contribution that makes Armory CD Self-Hosted even better!</p><p>As we worked with our customers pushing the limits of deployments at scale, we saw scenarios where enabling concurrent pipeline executions would cause performance degradations and timeouts, but disabling concurrency was not fast enough for the deployment frequency goals of the team.</p><p>Max Concurrent Pipeline Executions allows you to throttle the number of maximum parallel pipeline executions, so you can dial in your pipeline to maximize deployment frequency without encountering any performance degradations or timeouts. This effectively allows you to continue accelerating your deployment frequency and velocity and speed up your time-to-market with exciting new features and products.</p><p>You can find the Max Concurrent Pipeline Executions feature in your pipeline’s Configuration section. It is disabled by default:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/920/0*g0ehsncXiiiRv2ER" /></figure><h3>What’s next?</h3><ol><li>Check out the <a href="https://docs.armory.io/armory-enterprise/release-notes/rn-armory-spinnaker/armoryspinnaker_v2-28-0/?utm_source=mediumpub&amp;utm_medium=Stories">Armory CD Self-Hosted release notes</a> for all the changes</li><li>Talk to us about making the world better with software in the <a href="https://spinnaker.io/docs/community/#slackhttpjoinspinnakerio">Spinnaker Slack</a>! We’re over in <strong>#armory</strong></li><li>We are so excited about the open source contributions for <em>AWS Launch Templates</em> that we plan to tell that story in a dedicated future post! Stay tuned.</li></ol><p>Thank you for changing the world with cool software. It’s time to build!</p><p>See you out there,</p><p>Randall Abele, Group Product Manager</p><p><em>Originally published at </em><a href="https://www.armory.io/blog/self-hosted-and-managed-v228/?utm_source=mediumpub&amp;utm_medium=Stories"><em>https://www.armory.io </em></a><em>on August 2, 2022.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=87562d236db" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/armory-continuous-deployment-self-hosted-and-managed-v2-28-87562d236db">Armory Continuous Deployment Self-Hosted and Managed v2.28</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Horizontal Pod Autoscaling during Kubernetes deployments]]></title>
            <link>https://medium.com/armory/horizontal-pod-autoscaling-during-kubernetes-deployments-3b48727de040?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/3b48727de040</guid>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[canary-deployments]]></category>
            <category><![CDATA[horizontal-scaling]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[blue-green-deployment]]></category>
            <dc:creator><![CDATA[Parth Srivastav]]></dc:creator>
            <pubDate>Thu, 11 Aug 2022 18:20:07 GMT</pubDate>
            <atom:updated>2022-08-11T18:20:07.803Z</atom:updated>
            <content:encoded><![CDATA[<p>Autoscaling, which helps to optimize utilization and minimize costs, is one of the most important aspects of cloud computing. Autoscaling dynamically allocates resources to your cloud application based on load. It handles bursts of load and traffic during peak hours, ensuring that end user experience is not degraded. Autoscaling also guarantees that you don’t have servers running idle and costing you money in the non-peak hours.</p><h3>Autoscaling in Kubernetes</h3><p>In the Kubernetes world, there are 3 different autoscalers that help manage costs and resource optimization:</p><ul><li><strong>Cluster Autoscaler</strong> scales the number of worker nodes on the Kubernetes cluster. Most cloud Kubernetes providers like EKS, GKE, and AKS support some form of Cluster Autoscaler, but they each have their own “<a href="https://github.com/kubernetes/autoscaler/tree/master/cluster-autoscaler#faqdocumentation">gotchas</a>”.</li><li><strong>Vertical Pod Autoscaler</strong> (VPA) manages traffic surges by altering the resource requests and limits on pods, giving pods more resources when needed. This frees up the user from having to set up optimal CPU and memory requests. However, VPA requires pods to restart to apply the new recommended CPU and memory recommendations. Restarting pods may lead to interruption of service to end users of the service.</li><li><strong>Horizontal Pod Autoscaler</strong> (HPA) manages the number of pods based on the load. When the load increases, HPA creates identical replicas of the application and distributes load among different pods. The main advantage that HPA gives over VPA is increased reliability. HPA scales a larger number of smaller pods that are packed more efficiently across nodes. This ensures minimal disruption of service should a single node fail. HPA is the only autoscaling resource supported in the standard Kubernetes API.</li></ul><p>HPA presents unique challenges when used in conjunction with advanced deployment strategies like Blue/Green. For instance, one of our customers wanted to use a Blue/Green strategy to move all users on the old version to the new version without interruption. However, what our customer discovered was that HPA scaled down the next version as it was not receiving any traffic. This meant that end users saw slow/degraded service for a while when traffic cut over to the next version. When Armory set out to add support for HPA within Continuous Deployments-as-a-Service, we wanted to provide reliability when using deployment strategies without having to increase costs for our customers. Here’s what we came up with.</p><h3>How Armory’s Continuous Deployment-as-a-Service optimizes HPA during deployment</h3><p><strong>Step 1</strong>: Before starting a deployment to an environment, CD-as-a-Service notes the scale that your application is currently running at and maintains this scale until the deployment to the environment is finished.</p><p><strong>The Details</strong>: Because CD-as-a-Service knows the scale right before the deployment starts, it can alter deployment strategies in a way that does not cause degraded service. For example, when using a Blue/Green strategy, the next version of the application is scaled up to meet the current traffic load before traffic is moved over to the new version. Once the traffic is cut over to the new version, your users would not experience interruptions or degraded service. Additionally, this approach ensures reliability and speed when rolling back — your rollbacks don’t have to scale up to support the required traffic.</p><p><strong>Step 2</strong>: CD-as-a-Service then disables the HPA for your application and executes your deployment strategy.</p><p><strong>The Details</strong>: By disabling HPA during the deployment strategy, CD-as-a-Service ensures that HPA does not interfere with that strategy. For example, when using automated analysis results, if the new version has a memory leak, the HPA could scale up and thwart the threshold-based queries. Or during <a href="https://www.armory.io/blog/progressive-canary-with-armory-cd-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories">pod-ratio canary deployments</a>, HPA could scale down pods and force more users into the canary version of the application.</p><p><strong>Step 3</strong>: After successfully deploying the new version of the application, CD-as-a-Service then enables HPA for the new version of the application.</p><p><strong>The Details</strong>: CD-as-a-Service deploys every change you make, even changes to the HPA. That means as you refine your HPA configuration to the application’s needs, you can run automated performance tests in staging environments before ever deploying new HPA configurations to production.</p><p><strong>In Conclusion:</strong></p><p>With CD-as-a-Service, you can leverage all the benefits of HPA alongside advanced deployment strategies to deploy reliably without causing service interruptions. You can start using HPA with your applications by adding it to the list of manifests without adding any extra configuration. Test out your own HPA <a href="https://www.armory.io/products/continuous-deployment-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=managed_product_page">deployment scenarios by trying CD-as-a-Service for free by signing up today!</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b48727de040" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/horizontal-pod-autoscaling-during-kubernetes-deployments-3b48727de040">Horizontal Pod Autoscaling during Kubernetes deployments</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Progressive Delivery Drives Fast Feedback and Insights]]></title>
            <link>https://medium.com/armory/how-progressive-delivery-drives-fast-feedback-and-insights-f62e51e83e09?source=rss----6f479360264a---4</link>
            <guid isPermaLink="false">https://medium.com/p/f62e51e83e09</guid>
            <category><![CDATA[continuous-delivery]]></category>
            <category><![CDATA[progressive-delivery]]></category>
            <category><![CDATA[continuous-deployment]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Stephen Atwell]]></dc:creator>
            <pubDate>Wed, 10 Aug 2022 20:44:00 GMT</pubDate>
            <atom:updated>2022-08-11T03:18:21.862Z</atom:updated>
            <content:encoded><![CDATA[<p>Software has grown exponentially across all industries in the last decade, both in adoption and complexity. This growth is due in part to digitization across sectors. It’s also in part because of the constant evolution of software development practices, which enable developers to build more exciting software better and faster.</p><p>Agile methodology has become the de facto standard for software development. Developers satisfy customers through early and <a href="https://www.armory.io/products/continuous-deployment-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories%20&amp;utm_campaign=managed_product_page">continuous delivery </a>of valuable software, then accommodate changing requirements throughout the development process.</p><p>Many companies have adopted some form of continuous delivery (CD) to reduce the feedback cycle, improving their software quality and development speed by steadily fixing bugs and adding features. Customers quickly get their requested changes instead of waiting months until the next software version.</p><p>We’ll explore how continuous delivery and progressive delivery enable a continuous feedback loop to improve software quality then discuss how Armory helps.</p><h3>Continuous Delivery</h3><p>Continuous delivery releases code changes automatically, either internally or externally. This makes a deployment repeatable, reliable, and predictable. When deployments are easy and reliable, it frees your developers to work on features instead of troubleshooting the deployment. They can then take the time to follow best practices instead of cutting corners on the deployment configuration.</p><p>So how can you use modern continuous delivery practices to improve software quality and delivery speed? By deploying often.</p><p>A modern application typically contains a few different components, each hosted on multiple machines behind a load balancer.</p><p>When your engineers release an application, they must deploy the code to not just one server, but all servers hosting the services. This method is both tedious and error-prone. Tools like Kubernetes help automate this process, enabling CD pipelines to push changes to the entire cluster using one simple command.</p><p>The ability to automatically push changes reduces your software development cycle’s feedback interval, increasing your software quality and delivery speed.</p><h3>Progressive Delivery Drives Continuous Feedback</h3><p>Progressive delivery builds on continuous delivery with two main additions: the use of feature flags to test code in production and progressive rollouts.</p><p>Many techniques have evolved to facilitate a rapid feedback cycle. Modern techniques like canary and blue-green deployments progressively release the application. These methods deliver the changes to only a subset of users, making it possible to safely test new features and gather data in a real production environment without a huge impact.</p><p>With progressive delivery, the development and release cycle typically looks like this:</p><ol><li>Teams develop code, commit it, and prepare it for release.</li><li>They release the code to selected targets.</li><li>Companies gather relevant data through user feedback, telemetry, or statistics, and use the information to plan the next round of app improvements.</li><li>The cycle repeats.</li></ol><p>One possible release strategy is to push the release to only internal stakeholders. Teams release the version to a broader public when internal stakeholders are satisfied with the changes. Customers won’t see the features stakeholders aren’t satisfied with in the release.</p><p>To optimize learning, progressive deployment can push new designs to a subset of real users and gather real usage data from a live production environment.</p><p>With the help of an observability tool, you can gather and aggregate all kinds of data relevant to your application, including logs, events, performance, and errors. Such tools collect data and also analyze the information to help developers resolve issues faster.</p><p>Now all the stakeholders have reliable and indisputable data to learn from. For example, your development team may have a solution to a performance problem, and they want to test it out by deploying to just 10 percent of the traffic through canary releases. As performance and usage data comes in, your team can roll out to more users and observe when performance degradation happens using real load. It’s usually challenging to simulate load using internal tools but possible with progressive delivery.</p><p>Iterative development is the engine of a rapid continuous feedback loop that cycles between development, feedback, improvement, and delivery.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/481/0*UOLFwp6jcgzJsLAQ.png" /></figure><p>Using a progressive delivery strategy can minimize downtime for each release. After-hours or midnight deployments are no longer necessary. Customers are happy, your release engineers are at peace, and your product analysts have the data they need to drive the next round of improvements.</p><h3>Armory Enables CD and Progressive Delivery</h3><p>Thanks to tools like Armory, developers can confidently release their changes to production and help stakeholders gather the information they need to drive the next round of iteration. Armory is an enterprise-grade version of Spinnaker, a continuous delivery tool built on best practices learned by delivering software at scale.</p><p>The software has many built-in features for you to implement progressive delivery with confidence:</p><ul><li>Canary analysis is available out of the box. It’s easy to create a canary image before each deployment, collect some data, then either manually decide to push the release or make the decision automatically within a pipeline.</li><li>Once the application is released, you can undo the release through a pipeline or with a manual button click.</li><li>You can <a href="https://www.armory.io/products/scale-agent-for-spinnaker-kubernetes/?utm_source=mediumpub&amp;utm_medium=Stories">scale Kubernetes deployments</a>. When the number of clusters grows, it’s typical to experience latency issues, and managing configuration and credentials also becomes a logistical nightmare. The Armory agent for Kubernetes addresses both concerns with a decentralized model and scales to thousands of clusters with ease.</li><li>Its policy engine ensures every rollout meets a set of codified standards. By setting appropriate policies, you can ensure every deployment is compliant with your organization’s standards, unifying DevOps and SecOps in the release process.</li></ul><p>While you can implement progressive deployment with other tools like Kubernetes, Armory enables continuous delivery at scale.</p><p>For companies seeking a SaaS deployment solution, Armory also offers <a href="https://docs.armory.io/armory-enterprise/armory-admin/policy-engine/policy-engine-use?utm_source=mediumpub&amp;utm_medium=Stories">Armory CD-as-a-Service</a>. CD-as-a-Service delivers intelligent deployments-as-a-service so that your developers can focus on building great code, rather than deploying it. CD-as-a-Service is a drop in replacement for kubectl that can deploy using progressive deployments. CD-as-a-Service has a free trial and free tier available, so g<a href="https://docs.armory.io/armory-enterprise/armory-admin/policy-engine/policy-engine-use?utm_source=mediumpub&amp;utm_medium=Stories">ive it a try today.</a></p><h3>Conclusion</h3><p>As software complexity has grown, the deployment process has become challenging. You can simplify this process with tools like Kubernetes to roll out changes to a cluster of servers at the click of a button, but that’s not all that continuous delivery is good for.</p><p>Today, progressive delivery powers many of the world’s best tech companies as the engine of a continuous learning cycle. Companies progressively roll out their product, gather accurate usage data in a real production environment, and use the information to help build their products.</p><p>Using Spinnaker as its core, Armory facilitates progressive delivery at scale, giving your developers the power to deploy with confidence. We invite you to check out <a href="https://www.armory.io/blog/progressive-canary-with-armory-cd-as-a-service/?utm_source=mediumpub&amp;utm_medium=Stories">what Armory can do for you.</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f62e51e83e09" width="1" height="1" alt=""><hr><p><a href="https://medium.com/armory/how-progressive-delivery-drives-fast-feedback-and-insights-f62e51e83e09">How Progressive Delivery Drives Fast Feedback and Insights</a> was originally published in <a href="https://medium.com/armory">Armory</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>