GitHub Actions – Automate Your Development Workflow
- What GitHub Actions is and why development teams use it.
- How workflows, events, jobs, steps, and runners work together.
- How to create a CI pipeline for a .NET application.
- How to run workflows for pushes, pull requests, and manual execution.
- How to use secrets, environment variables, artifacts, and permissions.
- How to apply security and production best practices.
1. Introduction – Why Do We Need Automation?
Imagine a development team working on an employee management application. Every developer commits code to a shared GitHub repository. Before the changes can be merged, someone must restore dependencies, compile the application, run unit tests, check for errors, and prepare the deployment package.
If the team performs these activities manually for every change, the process becomes slow and inconsistent. A developer may forget to execute a test. Another developer may use a different build configuration. A problem may reach the main branch because the verification process was skipped.
This is where GitHub Actions becomes useful. It allows teams to define automated workflows directly inside their GitHub repositories.
For example, whenever a developer opens a pull request, GitHub Actions can automatically build the application and execute its unit tests. The team can review the results before merging the code.
2. What Is GitHub Actions?
GitHub Actions is GitHub's automation and CI/CD platform. It allows developers to automate repository-related tasks using workflows defined in YAML files.
A workflow can start when a specific event happens in a repository. For example:
- A developer pushes a commit to the
mainbranch. - A pull request is opened or updated.
- A new release is published.
- A scheduled time is reached.
- A developer manually starts a workflow.
After the workflow starts, GitHub executes the configured jobs on available runners. Each job contains one or more steps, such as checking out source code, installing a runtime, restoring dependencies, building the application, and running tests.
GitHub Actions and CI/CD
GitHub Actions is commonly used to implement two important software delivery practices:
- Continuous Integration (CI): Automatically build and validate code changes so integration problems are detected early.
- Continuous Delivery or Deployment (CD): Automate the process of preparing or releasing validated software to an environment.
CI and CD are related, but they are not the same. A workflow that builds and tests code is a CI workflow. A workflow that deploys an application to a server or cloud environment performs a deployment activity.
3. Understanding the Core Components
Before creating a workflow, understand the main building blocks of GitHub Actions.
| Component | Meaning | Example |
|---|---|---|
| Workflow | A complete automated process defined in a YAML file. | Build and Test |
| Event | The activity that triggers a workflow. | push, pull_request |
| Job | A group of steps executed on a runner. | build, test, deploy |
| Step | An individual task inside a job. | Restore dependencies |
| Action | A reusable unit of automation used as a workflow step. | actions/checkout |
| Runner | The machine that executes a job. | ubuntu-latest |
3.1 Workflow
A workflow is an automated process stored as a YAML file inside the repository's .github/workflows directory.
For example:
.github/
└── workflows/
└── dotnet-ci.yml
A repository can contain multiple workflows. One workflow may validate pull requests, another may publish a package, and another may deploy the application.
3.2 Events
An event determines when a workflow should run. GitHub provides several built-in events.
on:
push:
branches:
- main
pull_request:
branches:
- main
workflow_dispatch:
In this example, the workflow can run when code is pushed to main, when a pull request targeting main is opened or updated, or when a user manually starts the workflow.
3.3 Jobs
A job is a collection of steps that run together on a runner. By default, jobs can run in parallel. You can use needs to make one job wait for another job to complete successfully.
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Build application
run: echo "Building application"
deploy:
needs: build
runs-on: ubuntu-latest
steps:
- name: Deploy application
run: echo "Deploying application"
Here, the deployment job starts only after the build job completes successfully.
3.4 Steps
Steps are individual operations inside a job. A step can execute a shell command using run or use a reusable action using uses.
steps:
- name: Check out repository
uses: actions/checkout@v5
- name: Display message
run: echo "Workflow started"
3.5 Actions
An action is a reusable automation component. Instead of writing every operation from scratch, you can use actions maintained by GitHub, technology vendors, or the community.
For example, actions/checkout checks out repository content so that subsequent steps can access the source code.
3.6 Runners
A runner is the machine that executes a job. GitHub-hosted runners are managed by GitHub. You can also configure self-hosted runners on infrastructure that your organization manages.
Common GitHub-hosted runner labels include:
ubuntu-latest– Linux environment.windows-latest– Windows environment.macos-latest– macOS environment.
4. How GitHub Actions Works – Visual Workflow
Let's understand the complete execution flow using a practical example. A developer pushes code to GitHub. The push event triggers a workflow, GitHub allocates a runner, and the runner executes the configured build and test steps.
The workflow moves from a repository event to runner execution, validation, and a reported result. The animated paths indicate the direction of execution; the labels remain stationary.
Execution sequence
A developer commits and pushes changes to the repository.
GitHub checks whether the push matches the event and branch conditions configured in the workflow.
GitHub loads the YAML workflow and identifies the jobs that need to run.
A suitable runner is allocated and executes the steps in the job.
The runner restores dependencies, compiles the application, and runs automated tests.
GitHub displays the workflow status and logs. Developers can inspect failures and fix the issues.
5. Setting Up Your First GitHub Actions Workflow
Now let's create a practical CI workflow for a .NET application. The objective is simple: whenever a developer pushes code or creates a pull request targeting the main branch, GitHub Actions should restore dependencies, build the solution, and execute tests.
Prerequisites
- A GitHub account.
- A GitHub repository containing a .NET solution.
- A solution file such as
EmployeeManagement.sln. - At least one test project in the solution.
5.1 Create the workflow directory
Inside your repository, create the following directory structure:
EmployeeManagement/
│
├── src/
│ └── EmployeeManagement.Api/
│
├── tests/
│ └── EmployeeManagement.Tests/
│
├── EmployeeManagement.sln
│
└── .github/
└── workflows/
└── dotnet-ci.yml
GitHub automatically discovers supported workflow YAML files stored inside .github/workflows/.
5.2 Create the CI workflow
Open dotnet-ci.yml and add the following configuration.
Example 1: .NET build and test workflow
name: Employee Management CI
on:
push:
branches:
- main
- develop
pull_request:
branches:
- main
workflow_dispatch:
permissions:
contents: read
jobs:
build-and-test:
name: Build and Test
runs-on: ubuntu-latest
steps:
- name: Check out source code
uses: actions/checkout@v5
- name: Set up .NET
uses: actions/setup-dotnet@v5
with:
dotnet-version: '10.0.x'
- name: Restore dependencies
run: dotnet restore EmployeeManagement.sln
- name: Build solution
run: dotnet build EmployeeManagement.sln --configuration Release --no-restore
- name: Run unit tests
run: dotnet test EmployeeManagement.sln --configuration Release --no-build
5.3 Understand the workflow configuration
Let's understand the important sections of this YAML file.
Workflow name
name: Employee Management CI
This name appears in the GitHub Actions interface. It helps developers identify the workflow.
Trigger configuration
on:
push:
branches:
- main
- develop
pull_request:
branches:
- main
workflow_dispatch:
This configuration defines three ways to start the workflow:
push– Runs when commits are pushed to the specified branches.pull_request– Runs for pull request activity targeting the main branch. By default, pull request workflows can run for events such as opening, synchronizing, or reopening a pull request.workflow_dispatch– Allows an authorised user to start the workflow manually from GitHub.
Permissions
permissions:
contents: read
This limits the workflow's GITHUB_TOKEN to read repository contents. The checkout step can read the source code, while the workflow does not receive unnecessary write permissions.
Runner configuration
runs-on: ubuntu-latest
This tells GitHub to execute the job on a GitHub-hosted Ubuntu runner.
Set up .NET
- name: Set up .NET
uses: actions/setup-dotnet@v5
with:
dotnet-version: '10.0.x'
This uses the setup-dotnet action to make the specified .NET SDK available to subsequent steps. The version should match the SDK supported by your solution and your organisation's support policy.
Restore, build, and test
- name: Restore dependencies
run: dotnet restore EmployeeManagement.sln
- name: Build solution
run: dotnet build EmployeeManagement.sln --configuration Release --no-restore
- name: Run unit tests
run: dotnet test EmployeeManagement.sln --configuration Release --no-build
These commands perform the same core activities that a developer would normally execute from a local terminal. The workflow automates them on the runner.
6. Running the Workflow on GitHub
After creating the YAML file, commit and push it to your repository.
Terminal commands
git add .github/workflows/dotnet-ci.yml
git commit -m "Add GitHub Actions CI workflow"
git push origin main
Once the commit reaches GitHub, the push event can trigger the workflow.
Where can you see the execution?
Open your repository on GitHub.
Select the Actions tab.
Find the workflow named Employee Management CI.
Open the workflow run to inspect its jobs and individual step logs.
Illustrative workflow execution result
Employee Management CI
Run: Build and Test
✓ Check out source code
✓ Set up .NET
✓ Restore dependencies
✓ Build solution
✓ Run unit tests
Workflow completed successfully.
Illustrative result only. Actual logs and test summaries depend on your repository, SDK, test projects, and execution environment.
7. Understanding Jobs and Job Dependencies
As your application grows, you may want to separate validation into multiple jobs. For example, one job can build the application, another can run unit tests, and a third can perform a code-quality check.
Consider the following example:
Example 2: Multiple jobs with dependencies
name: Application Validation
on:
pull_request:
branches:
- main
permissions:
contents: read
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v5
- name: Set up .NET
uses: actions/setup-dotnet@v5
with:
dotnet-version: '10.0.x'
- name: Build
run: dotnet build EmployeeManagement.sln
test:
needs: build
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v5
- name: Set up .NET
uses: actions/setup-dotnet@v5
with:
dotnet-version: '10.0.x'
- name: Run tests
run: dotnet test EmployeeManagement.sln
The needs: build property creates a dependency between the jobs. The test job waits until the build job succeeds.
Without this dependency, the two jobs could run in parallel. Each job uses its own runner, so the test job checks out the source code and prepares its own .NET environment.
8. Important GitHub Actions Concepts
8.1 Environment variables
Environment variables allow you to share configuration values with commands and actions. They are useful for values that are not confidential, such as build configuration names or application environment labels.
jobs:
build:
runs-on: ubuntu-latest
env:
BUILD_CONFIGURATION: Release
steps:
- name: Display configuration
run: echo "Configuration is $BUILD_CONFIGURATION"
- name: Build application
run: dotnet build --configuration $BUILD_CONFIGURATION
You can define environment variables at workflow, job, or step level. A variable defined at a narrower level can override a variable with the same name at a broader level.
8.2 Secrets
Applications often need sensitive information such as API tokens, database credentials, or deployment credentials. These values should not be written directly into workflow YAML files or committed to source control.
GitHub provides repository, environment, and organisation-level secrets. A workflow can access an authorised secret through the secrets context.
Example 3: Using a repository secret
name: Deployment Example
on:
workflow_dispatch:
permissions:
contents: read
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Use deployment token
env:
DEPLOYMENT_TOKEN: ${{ secrets.DEPLOYMENT_TOKEN }}
run: |
if [ -z "$DEPLOYMENT_TOKEN" ]; then
echo "Deployment token is not configured"
exit 1
fi
echo "Deployment credentials are available"
To configure the secret, open your repository settings and navigate to Secrets and variables → Actions. Create a repository secret named DEPLOYMENT_TOKEN.
8.3 Artifacts
Artifacts are files produced during a workflow run that you want to store and access later. Examples include build packages, test reports, and diagnostic files.
For example, after publishing a .NET application, you can upload the output directory as an artifact.
- name: Publish application
run: dotnet publish src/EmployeeManagement.Api/EmployeeManagement.Api.csproj
--configuration Release
--output ./publish
- name: Upload publish output
uses: actions/upload-artifact@v4
with:
name: employee-management-publish
path: ./publish
The uploaded artifact can be downloaded from the workflow run, subject to the repository's artifact retention and access settings.
8.4 Job outputs
Sometimes one job calculates a value that another job needs. GitHub Actions supports job outputs for passing small values between dependent jobs.
jobs:
prepare:
runs-on: ubuntu-latest
outputs:
release_name: ${{ steps.release.outputs.name }}
steps:
- id: release
run: echo "name=release-2026" >> "$GITHUB_OUTPUT"
publish:
needs: prepare
runs-on: ubuntu-latest
steps:
- name: Display release name
run: echo "Publishing ${{ needs.prepare.outputs.release_name }}"
Job outputs are useful for passing metadata and identifiers. For large files, use artifacts instead.
8.5 Conditional execution
You can control whether a step or job runs using expressions and conditions.
steps:
- name: Run production deployment
if: github.ref == 'refs/heads/main'
run: echo "Deploying production build"
This step runs only when the workflow reference is the main branch. Conditions are especially useful when the same workflow supports different branches or environments.
8.6 Matrix strategy
A matrix strategy runs the same job with multiple combinations of configuration values. It is useful when you need to test an application across multiple operating systems or runtime versions.
jobs:
test:
runs-on: ${{ matrix.os }}
strategy:
matrix:
os:
- ubuntu-latest
- windows-latest
dotnet-version:
- '8.0.x'
- '10.0.x'
steps:
- uses: actions/checkout@v5
- name: Set up .NET
uses: actions/setup-dotnet@v5
with:
dotnet-version: ${{ matrix.dotnet-version }}
- name: Run tests
run: dotnet test EmployeeManagement.sln
This configuration creates multiple job combinations. Each combination uses the selected operating system and .NET SDK version.
9. Common GitHub Actions Events
Events determine when a workflow is triggered. Selecting the correct event is important for building reliable automation.
| Event | When it is used |
|---|---|
push |
When commits are pushed to a repository reference. |
pull_request |
When pull request activity occurs, such as opening or updating a PR. |
workflow_dispatch |
When a user manually starts a workflow. |
schedule |
When a configured cron schedule is reached. |
release |
When release activity occurs. |
issues |
When issue activity occurs, such as opening an issue. |
workflow_run |
When another workflow run completes or reaches a configured activity. |
Scheduled workflow example
You can configure a workflow to run automatically using a cron expression.
name: Scheduled Maintenance
on:
schedule:
- cron: '0 2 * * 1'
jobs:
maintenance:
runs-on: ubuntu-latest
steps:
- name: Run maintenance check
run: echo "Running weekly maintenance"
The expression 0 2 * * 1 represents 02:00 every Monday in UTC. Scheduled workflows use UTC, and execution can be delayed during periods of high GitHub Actions load.
10. GitHub Actions for a Real-World CI/CD Pipeline
In a production application, automation usually involves more than compiling source code. A typical delivery pipeline may include several stages.
A simplified delivery pipeline. Production approval, security checks, and deployment strategies should be added according to the application's requirements.
Typical pipeline stages
- Source: A developer pushes code or opens a pull request.
- Restore: Required dependencies are restored.
- Build: The application is compiled.
- Test: Unit and integration tests are executed.
- Package: A deployable artifact or container image is created.
- Approval: A protected environment may require an authorised reviewer.
- Deploy: The validated package is released to the target environment.
Not every project needs every stage. A small application may only need build and test automation, while an enterprise application may require separate development, staging, and production deployment workflows.
11. Deployment Environments and Approvals
GitHub environments allow teams to represent deployment targets such as Development, Staging, and Production. An environment can have protection rules, required reviewers, deployment branch restrictions, and environment-specific secrets or variables depending on repository and plan capabilities.
For example, a production deployment job can reference an environment:
jobs:
deploy-production:
runs-on: ubuntu-latest
environment: production
steps:
- name: Deploy application
run: echo "Deploying to production"
When protection rules are configured for the production environment, GitHub can require approval before the job proceeds.
12. Security Best Practices
GitHub Actions executes code and commands on runners. A poorly secured workflow can expose credentials, modify repository content, or access external systems. Security must be considered while designing the pipeline.
12.1 Follow the principle of least privilege
Grant only the permissions required by a workflow or job. For example, a workflow that only checks out code and runs tests usually needs read access to repository contents.
permissions:
contents: read
If a particular job needs additional permissions, define them at the job level instead of granting broad permissions to every job.
12.2 Never hardcode secrets
Do not store passwords, access tokens, private keys, or connection strings directly in YAML files or source code. Use GitHub secrets or a suitable external secret-management system.
12.3 Review third-party actions
Before using a third-party action, review its source code, maintainer, permissions, dependencies, and security history. For sensitive production workflows, pin actions to a verified full commit SHA rather than relying only on a mutable version tag.
12.4 Protect deployment workflows
Use environment protection rules, restricted deployment branches, and approval requirements where appropriate. Do not allow untrusted pull request code to access production credentials.
12.5 Use OIDC where supported
When a cloud provider supports OpenID Connect federation, GitHub Actions can request a short-lived identity token and exchange it for temporary cloud credentials. This can reduce the need to store long-lived cloud access keys as GitHub secrets.
A workflow that uses OIDC needs the relevant permission:
permissions:
contents: read
id-token: write
The cloud provider must also be configured to trust the intended GitHub repository and workflow identity. The trust policy should restrict which repositories, branches, or environments are allowed to obtain credentials.
id-token: write allows a workflow to request an OIDC token. It does not itself grant permission to modify cloud resources. Actual access depends on the trust relationship and permissions assigned by the cloud provider.13. Common Mistakes and Troubleshooting
| Problem | Possible reason | What to check |
|---|---|---|
| Workflow does not start | Incorrect event or branch filter. | Check the YAML trigger and target branch. |
| Workflow file is ignored | File is outside the workflows directory or has an unsupported extension. | Check .github/workflows/ and the YAML file name. |
| Build fails | SDK mismatch or compilation error. | Check the SDK version and build logs. |
| Tests fail | Test failure or environment dependency. | Inspect test output and required configuration. |
| Secret is empty | Secret is missing or unavailable to the event context. | Check secret name, scope, and trigger restrictions. |
| Permission denied | Token lacks the required permission. | Review workflow and job permissions. |
| Artifact not found | Artifact upload did not complete or the path is incorrect. | Check the upload step and artifact name. |
Debugging checklist
- Open the failed workflow run in the Actions tab.
- Identify the job and step that failed.
- Read the complete error message in the logs.
- Verify the runner operating system and installed tools.
- Check the YAML indentation and expression syntax.
- Verify branch filters, event types, and required permissions.
- Confirm that required secrets and variables are configured.
- Re-run the workflow after correcting the actual cause.
14. GitHub Actions Best Practices for Development Teams
For production-ready automation, follow these practices:
- Keep workflows focused: Create separate workflows for unrelated responsibilities when that makes maintenance easier.
- Use meaningful names: Give workflows, jobs, and steps clear names so developers can understand execution logs.
- Use least-privilege permissions: Start with minimal token permissions and add only what is required.
- Pin important actions: Review action versions and consider full commit SHA pinning for sensitive workflows.
- Cache dependencies carefully: Use caching to reduce repeated dependency downloads where it is appropriate.
- Use artifacts for build outputs: Transfer generated files between jobs instead of assuming runners share a filesystem.
- Separate CI and deployment responsibilities: Validate pull requests before allowing deployment activities.
- Protect production environments: Require approvals and restrict deployment sources where needed.
- Monitor workflow failures: Investigate repeated failures instead of repeatedly re-running without understanding the cause.
- Keep workflows maintainable: Reuse common workflow logic when multiple repositories or pipelines need the same process.
15. GitHub Actions vs Jenkins
GitHub Actions and Jenkins are both used for automation and CI/CD. However, they have different operating models and integration strengths.
| Area | GitHub Actions | Jenkins |
|---|---|---|
| Platform | Integrated into GitHub. | Separate automation server. |
| Configuration | YAML workflow files. | Jenkinsfiles and pipeline syntax. |
| Infrastructure | GitHub-hosted or self-hosted runners. | Usually managed Jenkins controllers and agents. |
| Repository integration | Native GitHub integration. | Configured through plugins and integrations. |
| Extensibility | Marketplace actions and custom actions. | Large plugin ecosystem. |
| Operations | GitHub manages hosted service infrastructure. | Organisation manages Jenkins infrastructure and maintenance. |
GitHub Actions is a natural option for teams already using GitHub for source control and collaboration. Jenkins can be useful when an organisation needs extensive control over its CI infrastructure, existing Jenkins integrations, or highly customised automation. The right choice depends on the team's architecture, security requirements, cost model, and operational capabilities.
16. Interview Questions and Answers
Q1. What is GitHub Actions?
Answer: GitHub Actions is GitHub's automation and CI/CD platform. It allows developers to define workflows that execute automatically in response to repository events or manual triggers.
Q2. What is a workflow in GitHub Actions?
Answer: A workflow is an automated process defined in a YAML file under .github/workflows/. It contains triggers, jobs, permissions, and other configuration.
Q3. What is the difference between a job and a step?
Answer: A job is a group of steps that executes on a runner. A step is an individual operation within that job, such as running a command or invoking an action.
Q4. What is a runner?
Answer: A runner is the execution environment that runs a job. It can be a GitHub-hosted machine or a self-hosted machine managed by the organisation.
Q5. What is the difference between uses and run?
Answer: uses invokes an action, while run executes shell commands directly on the runner.
Q6. How can you make one job depend on another?
Answer: Use the needs property. For example, needs: build makes a job wait for the build job to complete successfully before it starts.
Q7. What is the purpose of GitHub Actions secrets?
Answer: Secrets store sensitive values such as API tokens and credentials. Workflows can access authorised secrets through the secrets context without hardcoding the values in source files.
Q8. What is a matrix strategy?
Answer: A matrix strategy runs a job with multiple combinations of configuration values, such as operating systems or runtime versions. It helps validate compatibility across supported environments.
Q9. What is the difference between GitHub-hosted and self-hosted runners?
Answer: GitHub-hosted runners are managed by GitHub. Self-hosted runners are machines managed by the organisation. Self-hosted runners offer infrastructure control but require careful maintenance and security isolation.
Q10. How do you secure a GitHub Actions workflow?
Answer: Apply least-privilege token permissions, protect secrets, review third-party actions, restrict deployment environments, avoid executing untrusted code with privileged credentials, and use OIDC federation where supported.
Q11. How can you run a workflow manually?
Answer: Configure the workflow_dispatch event. The workflow can then be started manually from the Actions interface, subject to the user's permissions and workflow availability.
Q12. What is the difference between artifacts and caches?
Answer: Artifacts preserve files generated by a workflow run, such as build packages and test reports. Caches store reusable data, such as dependencies, to speed up future workflow executions. They serve different purposes.
Q13. What happens when a job fails?
Answer: A failed job is reported in the workflow run. Jobs that depend on it through needs are normally skipped unless their conditions explicitly allow execution. Independent jobs may still run.
Q14. How can GitHub Actions deploy to a cloud provider without storing long-lived access keys?
Answer: Use OpenID Connect federation when supported. Configure the cloud provider to trust the intended GitHub workflow identity, grant the workflow id-token: write, and exchange the identity token for short-lived cloud credentials.
Q15. How would you design CI/CD for an enterprise .NET application?
Answer: I would trigger CI for pushes and pull requests, restore dependencies, build the solution, run unit and integration tests, execute quality and security checks, and publish a versioned artifact. Deployment would use separate environments, restricted permissions, approval gates for production, and short-lived cloud credentials where supported. I would also include logging, failure notifications, rollback planning, and artifact traceability.
17. Hands-On Practice
Create a GitHub repository containing a simple .NET solution. Add a workflow that runs whenever a developer pushes code to the main branch.
Expected result: A workflow run should appear in the Actions tab and execute the configured build.
Update your workflow to run when a pull request targets the main branch. Include a build step and a test step.
Expected result: GitHub should display the workflow status for the pull request.
Create separate build and test jobs. Configure the test job to depend on the build job using needs.
Expected result: The test job should start only after the build job succeeds.
Create a repository secret and pass it to a workflow step through an environment variable. Do not print its value.
Expected result: The workflow should be able to detect that the secret is configured without exposing it in logs.
Configure a matrix to test your application on multiple supported operating systems or .NET SDK versions.
Expected result: GitHub should create separate job executions for the configured combinations.
18. Conclusion
GitHub Actions helps development teams automate the activities that happen around source code. Instead of relying on developers to manually build and test every change, teams can define repeatable workflows that execute whenever repository events occur.
In this article, we explored workflows, events, jobs, steps, actions, runners, CI pipelines, secrets, artifacts, matrix strategies, deployment environments, and security practices. We also created a practical .NET build-and-test workflow.
For real-world projects, start with a reliable CI pipeline. Make sure every pull request is validated before merging. Once the process is stable, introduce packaging, environment-based deployments, approvals, and secure cloud authentication as your application requires.
Remember: Good automation is not simply about reducing manual work. It is about making software delivery consistent, repeatable, secure, and easier to maintain.
19. Official Documentation and Further Learning
- GitHub Actions – Official Documentation
- Workflow Syntax
- Secure Use of GitHub Actions
- Using Secrets in GitHub Actions
- OpenID Connect in GitHub Actions
- actions/checkout
- actions/setup-dotnet
Upgradix by Shrash Studio – Learn Technology. Build Your Future.
Quality Technology Education. Completely Free.