<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>DevOps on Step Documentation</title>
    <link>https://step.dev/knowledgebase/30/devops/</link>
    <description>Recent content in DevOps on Step Documentation</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en</language>
    <lastBuildDate>Thu, 28 Feb 2019 14:08:01 +0100</lastBuildDate><atom:link href="https://step.dev/knowledgebase/30/devops/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Automation as Code</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-as-code/</link>
      <pubDate>Wed, 21 Aug 2024 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-as-code/</guid>
      <description>Step&amp;rsquo;s unique Software automation as Code approach (short Automation as code) enables developers to define software automation workflows for the whole DevOps lifecycle as code alongside the product code.
This concept is the key enabler for shift-left in not just testing but for all disciplines relating to software automation. This ranges from large scale E2E acceptance tests to load and performance tests, synthetic monitoring, RPA, and much more.
This pages presents the use-cases enabled by the Automation as Code approach.</description>
    </item>
    
    <item>
      <title>Automation Packages</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-packages-overview/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-packages-overview/</guid>
      <description>The concept of Automation Packages provides a standard for defining software automation workflows for the whole DevOps lifecycle in a unified way. Following the Automation as Code paradigm, it allows developers to define software automation logic as code alongside the actual application&amp;rsquo;s code, and provide all the means to execute and deploy this logic at the different stages of the DevOps lifecyle.
Technically the Automation Package standard consist of:
The Automation Package syntax that defines a standard to describe a wide range of automation workflows in a unified way The Automation Package format that defines a standard for packaging entities (like Keywords, Plans, Resources, data, etc) The Automation Package CLI that allows to build, execute and deploy Automation Packages Automation Packages in a nutshell In a nutshell an Automation Package is a self-contained set of Plans and their related entities (Keywords, Parameters, Resources&amp;hellip;) that can be executed on a Step controller or deployed to it for later use.</description>
    </item>
    
    <item>
      <title>Automation Package Descriptor</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-yaml/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-yaml/</guid>
      <description>Automation Packages are defined in a declarative way using YAML alongside the automation code. The Step Automation Package YAML syntax is specified by the Automation Package JSON schema, for more convenient work you can configure the embedded file editor in your IDE (IntelliJ IDEA or Visual Studio) to associate this schema with the Step YAML automation packages.
For Java Automation Packages, it is possible to directly declare certain entities in the code in addition to the YAML descriptor.</description>
    </item>
    
    <item>
      <title>Automation Package Libraries</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-libraries/</link>
      <pubDate>Mon, 24 Nov 2025 00:00:00 +0000</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-libraries/</guid>
      <description>Overview Automation Package Libraries (AP Libraries) extend Step’s Automation Package model by enabling common code, libraries and entities to be packaged, deployed, and referenced independently from individual Automation Packages (APs).
They offer a structured mechanism for sharing logic at scale and optimizing performance across large automation ecosystems.
AP Libraries are reusable, versioned code artifacts that can provide:
Shared logic across multiple Automation Packages Common utilities and helper classes Shared libraries Shared AP entities (Keywords, Plans) Important:</description>
    </item>
    
    <item>
      <title>Automation Packages Multi-version support</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-multi-version/</link>
      <pubDate>Fri, 21 Nov 2025 07:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-multi-version/</guid>
      <description>Overview Step allows deploying multiple versions of the same Automation Package on a single Step instance. This is particularly useful when your system under test (SUT) exists in several versions across different environments (e.g., TEST, QA, PROD), each requiring a matching version of the automation code.
Multi-version support enables:
several versions of the same package to coexist automatic version selection at runtime consistent usage of keywords and plans from the selected version clear and predictable behavior across environments Step determines the correct version using activation expressions associated with each deployment.</description>
    </item>
    
    <item>
      <title>Automation Package in Java</title>
      <link>https://step.dev/knowledgebase/30/devops/automation-package-java/</link>
      <pubDate>Wed, 22 May 2019 14:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/automation-package-java/</guid>
      <description>Automation package entities can be defined in a declarative way with the automation package descriptor (YAML) as well as directly in the code for Java Automation Packages. This page focuses on the declaration of Automation Package entities in the code which is supported for Keywords and Plans.
Declaration of Keywords In addition to the declaration of Keywords in the automation package descriptor (YAML), Automation packages also fully support the Keyword API to declare Keywords directly in Java.</description>
    </item>
    
    <item>
      <title>Getting started with Automation Packages</title>
      <link>https://step.dev/knowledgebase/30/devops/devops-getting-started/</link>
      <pubDate>Tue, 06 Feb 2024 00:08:01 +0100</pubDate>
      
      <guid>https://step.dev/knowledgebase/30/devops/devops-getting-started/</guid>
      <description>The easiest way to get started with Automation Packages is to use one of our tutorial projects.
Load and performance tests For automated and continuous performances tests, the tutorials include a complete project definition with a few simple keywords and plans defining a short load test scenario. It should be straightforward to execute these projects and start from there by modifying them according to your needs.
Browser-based load testing with Playwright Protocol-based load testing with okhttp Continuous load testing with Grafana K6 Synthetic Monitoring Similarly to the load and performance test scenario, the tutorial for synthetic monitoring contains simple keywords, execution plan and schedule to set up the synthetic monitoring.</description>
    </item>
    
  </channel>
</rss>
