Skip to main content

CI/CD Overview

This guide explains how CI/CD pipelines work on the Ybor Platform, including the reusable GitHub Actions and Workflows available to streamline your build process.

What You'll Learn​

  • How to use p6m-actions in your workflows
  • Categories of available actions
  • Required secrets and variables
  • How to customize or extend the standard workflows

Architecture​

The platform provides p6m-actions — individual GitHub Actions that perform specific tasks. They're composable and can be used directly in your workflows.

┌──────────────────────────────────────────────────────────────┐
│                    Your Workflow Files                       │
│              (.github/workflows/build.yml)                   │
└──────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌──────────────────────────────────────────────────────────────┐
│                       p6m-actions                            │
│           (Individual actions for specific tasks)            │
│                                                              │
│     setup → build → login → publish → release                │
└──────────────────────────────────────────────────────────────┘

Pipeline Stages​

Every CI/CD pipeline follows the same general flow, with language-specific actions at each stage:

1. Setup​

Configure the language toolchain and build environment. Each language has a setup action that installs the correct runtime, package manager, and dependencies.

2. Registry Login​

Authenticate with Artifactory to access private packages and prepare for publishing. This includes both language-specific package registries (PyPI, NuGet, Maven, Cargo) and Docker registries.

3. Build​

Compile, test, and package the application. Build actions run linters, execute tests, and produce artifacts ready for publishing.

4. Publish​

Push artifacts to registries. Most applications publish Docker images; libraries may also publish packages to language-specific registries.

5. Release​

Create semantic version tags and GitHub releases. The cut-tag actions bump versions in the appropriate manifest file (pyproject.toml, .csproj, pom.xml, Cargo.toml, package.json).

6. Deploy​

Trigger deployment by updating Kubernetes manifests with the new image digest. The platform-application-manifest-dispatch action handles this for all languages.

Language-Specific Actions​

Each language has its own set of actions following the stages above. See the language reference for complete details:

LanguageGuide
JavaScriptJavaScript Actions
PythonPython Actions
.NET.NET Actions
JavaJava Actions
RustRust Actions

Generic actions that work across all languages:

ActionDescription
docker-buildx-setupSet up Docker Buildx for multi-platform builds
docker-repository-loginLog in to Docker registries
repository-releaseCreate GitHub releases
platform-application-manifest-dispatchTrigger platform manifest updates for deployment

Required Secrets and Variables​

Configure these at the repository or organization level.

Managed by Ybor

These secrets and variables are provisioned by the Ybor platform during onboarding. If builds are failing due to missing credentials, contact your Admin or DevOps team to verify the configuration.

Secrets​

SecretDescription
ARTIFACTORY_USERNAMEArtifactory service account username
ARTIFACTORY_IDENTITY_TOKENArtifactory identity token for authentication
UPDATE_MANIFEST_TOKENToken for dispatching platform manifest updates

Variables​

VariableDescription
ARTIFACTORY_HOSTNAMEArtifactory server hostname (e.g., artifacts.example.com)
ARTIFACTORY_PROJECTProject name in Artifactory
PLATFORM_DISPATCH_URLURL for platform manifest dispatch endpoint

Example Workflow Structure​

Here's how a typical build workflow composes these actions. This example uses Python, but the structure is the same for all languages—see the Language Reference for language-specific actions.

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # 1. Setup toolchain
      - uses: p6m-actions/python-uv-setup@v1

      # 2. Login to registries
      - uses: p6m-actions/python-uv-repository-login@v1
        with:
          artifactory-hostname: ${{ vars.ARTIFACTORY_HOSTNAME }}
          artifactory-project: ${{ vars.ARTIFACTORY_PROJECT }}
          artifactory-username: ${{ secrets.ARTIFACTORY_USERNAME }}
          artifactory-token: ${{ secrets.ARTIFACTORY_IDENTITY_TOKEN }}

      # 3. Build and test (compiles code, runs tests, produces build artifacts)
      - uses: p6m-actions/python-uv-build@v1

      # 4. Build Docker image and push to registry
      #    The built artifacts from step 3 are packaged into the container
      #    The image digest output is used for deployment
      - uses: p6m-actions/python-uv-docker-publish@v1
        with:
          image: ${{ vars.ARTIFACTORY_HOSTNAME }}/${{ vars.ARTIFACTORY_PROJECT }}-docker-local/applications/my-service
          platforms: linux/amd64,linux/arm64

Customization Options​

Use Standard Actions Directly​

The simplest approach is to use p6m-actions directly in your workflow files. This gives you full control over the pipeline while benefiting from tested, maintained actions.

Fork and Modify​

If you need different behavior, fork the action repository and modify it:

  1. Fork the action from p6m-actions/<action-name>
  2. Make your changes
  3. Reference your fork: uses: your-org/action-name@v1

Build Custom Workflows​

For completely custom pipelines, ensure your build produces:

  • Container images pushed to your Artifactory Docker registry
  • Image digests for immutable deployment references
  • Semantic versions following the platform's versioning scheme
  • GitHub tags for release tracking (required for staging and production deployments)

The key integration point is the platform-application-manifest-dispatch action, which triggers deployments by updating Kubernetes manifests with your image digest.