• A developer notices that a specific action in their workflow is consistently failing. Upon inspecting the workflow configuration file, they find that the action is supposed to trigger every time a pull request is labeled 'urgent'. However, the action fails to trigger even when the label is correctly applied. What is the most likely reason for this issue? The event trigger in the workflow file is incorrectly configured.
• A GitHub Actions workflow consistently fails at a step utilizing a JavaScript action with an error message indicating an issue with the node version. What is the most appropriate way to address this issue? Add a step to update the node version in the runner environment before executing the JavaScript action.
• A GitHub Actions workflow consistently fails at a step utilizing a JavaScript action with an error message indicating an issue with the node version. What is the most appropriate way to address this issue? Add a step to update the node version in the runner environment before executing the JavaScript action.
• A GitHub Actions workflow fails during a step that executes a JavaScript action. The logs indicate a problem with a missing package. What is the most appropriate action to resolve this issue? Modify the JavaScript action to include a step for installing the missing package.
• A GitHub Actions workflow fails during a step that executes a JavaScript action. The logs indicate a problem with a missing package. What is the most appropriate action to resolve this issue? Modify the JavaScript action to include a step for installing the missing package.
• A workflow run has failed, and you need to diagnose the issue. Which of the following is the first step you should take? Review the logs of the failed run in the Actions tab of the GitHub repository.
• As a DevOps engineer, you're tasked with managing reusable components for your organization's workflows. What approach should you take? Store reusable components in a centralized repository, establish clear naming conventions, and create a maintenance plan.
• As a GitHub Actions administrator, which of the following practices should be included in your organizational use policies for GitHub Actions? Regularly audit and review actions to ensure compliance with security standards and organizational policies. AND Define clear guidelines for creating, using, and sharing GitHub Actions within the organization AND Establish a process for regular updates and maintenance of shared actions to address vulnerabilities and improve performance.
• As a GitHub organization administrator, you want to make a secret available to multiple repositories. What is the correct approach? Create an organization-level secret and select the repositories that should have access to it.
• As the lead of a DevOps team, you're tasked with managing reusable components for workflows. What approach should you adopt? Create a dedicated repository for reusable components, establish clear naming conventions, and document maintenance procedures.
• Consider you are managing workflows in a GitHub repository. Which of the following actions are correct in the context of GitHub Actions? Custom environment variables can be defined at the workflow, job, or step level for flexibility. AND Use the GITHUB_TOKEN secret to authenticate and perform actions with the GitHub API within a workflow. AND To view a history of all workflow runs, go to the Actions tab of the repository.
• During the execution of a Docker container action in a GitHub Actions workflow, you receive an error related to environment variables not being passed correctly. Which of the following steps is most likely to resolve the issue? Add the missing environment variables to the workflow's env section.
• For a custom GitHub Action designed to deploy applications to multiple cloud platforms, what is the most effective method to manage and configure platform-specific deployment settings? Utilize a configuration file in the user's repository to define platform-specific settings, which the action reads and applies during deployment. AND Require users to store platform-specific settings as encrypted secrets in their GitHub repository and reference these in the action.
• For a custom GitHub Action that requires periodic updates and maintenance, what is the best strategy to inform users about upcoming changes or deprecations that might affect their workflows? Use the action's code to display warning messages in the workflow logs when deprecated features are used., Update the README file of the action's repository with details about the changes and deprecations.
• For a custom GitHub Action you are developing, which method is most appropriate for debugging issues that occur during the action's execution in a workflow? Utilize console.log statements in the action's code and review the output in the GitHub Actions workflow logs.
• For a GitHub Action that requires frequent updates due to changes in external dependencies, what strategy should be employed to test and validate the action's functionality before releasing updates to ensure minimal impact on users? Set up an automated testing suite that runs tests against a variety of scenarios whenever changes are made, using GitHub Actions' own CI/CD capabilities.
• How are database and service containers utilized in a GitHub Actions workflow? By defining services in the workflow file, allowing jobs to use the containers as part of the runtime environment.
• How are database and service containers utilized in a GitHub Actions workflow? By defining services in the workflow file, allowing jobs to use the containers as part of the runtime environment.
• How are dependent jobs implemented in a GitHub Actions workflow? By using the needs keyword to specify job dependencies, ensuring that certain jobs run only after their dependencies have completed successfully.
• How are dependent jobs implemented in a GitHub Actions workflow? By using the needs keyword to specify job dependencies, ensuring that jobs run in the correct order.
• How are encrypted secrets accessed within GitHub Actions and workflows? By using the secrets context in the workflow file to reference the secrets.
• How are encrypted secrets accessed within GitHub Actions and workflows? By using the secrets context in the workflow file to reference the secrets.
• How are encrypted secrets accessed within GitHub Actions workflows? By using the secrets context in the workflow file to reference the secrets by name.
• How are encrypted secrets accessed within GitHub Actions workflows? By using the secrets context in the workflow file to reference the secrets by name.
• How can a custom script be integrated into a GitHub Actions workflow? By using the run keyword in a step within a job to execute the script.
• How can a script be incorporated into a GitHub Actions workflow? By using the run keyword in a step to execute shell commands or scripts.
• How can a workflow status badge be added to a repository's README file? Use the markdown code provided in the Actions tab of the repository to embed the status badge.
• How can caching be configured to speed up workflow execution in GitHub Actions? Use the cache action to store and retrieve dependencies, reducing installation time in subsequent runs.
• How can caching be configured to speed up workflow execution in GitHub Actions? Use the cache action to store and retrieve dependencies, reducing installation time in subsequent runs.
• How can data be passed between jobs in a GitHub Actions workflow? By using artifacts to share data between jobs in a workflow.
• How can workflow artifacts be removed from GitHub after they are no longer needed? Artifacts can be configured to automatically expire after a certain number of days.
• How can workflow artifacts be removed from GitHub after they are no longer needed? Artifacts can be configured to automatically expire after a certain number of days.
• How can you access encrypted secrets within a GitHub Actions workflow? Use the secrets context to access the secrets within your workflow file.
• How can you correctly call a reusable workflow in GitHub Actions? By specifying the workflow's file path in the uses keyword under a job.
• How can you correctly call a reusable workflow in GitHub Actions? By specifying the workflow's file path in the uses keyword under a job.
• How can you download workflow artifacts from the GitHub Actions user interface? Navigate to the Actions tab, select the specific workflow run, and download the artifacts from the Artifacts section at the bottom of the page.
• How can you enable step debug logging in a GitHub Actions workflow? By setting the ACTIONS_STEP_DEBUG secret to true in the repository settings.
• How can you identify a GitHub Action's type, inputs, and outputs? By reading the action's action.yml file, which defines the action's interface including its type, required inputs, and outputs.
• How can you identify a GitHub Action's type, inputs, and outputs? By reading the action's action.yml file, which defines the action's interface including its type, required inputs, and outputs.
• How can you identify the event that triggered a GitHub Actions workflow? By checking the GITHUB_EVENT_NAME environment variable in the workflow run logs.
• How can you identify the event that triggered a GitHub Actions workflow? By checking the GITHUB_EVENT_NAME environment variable in the workflow run logs.
• How can you trigger a GitHub Actions workflow in Repository B whenever a new release is published in Repository A, assuming both repositories are within the same organization? Use the repository_dispatch event in Repository B, and trigger it using a webhook from Repository A upon release.
• How can you use an organization's templated workflow in a repository? By selecting the template from the repository's Actions tab and then customizing it as needed.
• How do you ensure a workflow uses a specific version of a GitHub Action? By referencing the action in the workflow file with a version tag or commit SHA after the action's name (e.g., actions/checkout@v4).
• How should an appropriate distribution model for a GitHub Action be selected? Based on the intended audience and usage scope, choosing between public, private, or marketplace distribution.
• How should an organization configure use policies for GitHub Actions to ensure compliance and efficiency? Define clear guidelines on usage, security, and maintenance, and enforce them through automated checks and balances.
• If you're navigating a GitHub repository for the first time, where would you typically find the GitHub Actions workflow files? In the .github/workflows directory at the root of the repository.
• In a GitHub Actions workflow that is triggered by pull requests affecting any file, how can you configure a job to run only if a specific file has been modified and a preceding job has completed successfully? Combine the if condition and jobs.<job_id>.if attribute to check the success of a previous job and use a script step with git diff to verify if a specific file was modified
• In a GitHub Actions workflow that is triggered by pull requests affecting any file, how can you configure a job to run only if a specific file has been modified and a preceding job has completed successfully? Combine the if condition and jobs.<job_id>.if attribute to check the success of a previous job and use a script step with git diff to verify if a specific file was modified
• In a GitHub Actions workflow, how can you configure a job to reuse artifacts generated by a previous job in the same workflow? Implement the uses: actions/download-artifact@v2 step within the job, specifying the name of the artifact produced by the previous job.
• In a GitHub Actions workflow, how can you efficiently reduce duplication of code when the same steps are used across multiple jobs? Implement a custom action and reference it in each job where the steps are required.
• In a GitHub Actions workflow, how can you share data generated in one job with subsequent jobs in the same workflow? Use the upload-artifact and download-artifact actions to pass data between jobs.,
• In a GitHub Actions workflow, how should you handle exit codes from a script to ensure correct workflow behavior? Use the if conditional in the workflow file to check for specific exit codes and handle them accordingly.
• In a GitHub Actions workflow, how should you securely manage sensitive information like API keys or database credentials? Use GitHub Secrets and reference them in the workflow file using the ${{ secrets.SECRET_NAME }} syntax.
• In an enterprise environment, what is the best practice for monitoring and analyzing the usage and performance of GitHub Actions across multiple repositories and teams? Implement a centralized logging and monitoring system that aggregates data from all GitHub Actions workflows
• In an enterprise setting, how should a GitHub Actions workflow be configured to ensure that sensitive data, such as production database credentials, is securely managed and accessed only by authorized workflows? Store sensitive data as encrypted secrets in GitHub and restrict access to these secrets using GitHub's environment protection rules.
• In an enterprise setting, how should a GitHub Actions workflow be configured to ensure that sensitive data, such as production database credentials, is securely managed and accessed only by authorized workflows? Store sensitive data as encrypted secrets in GitHub and restrict access to these secrets using GitHub's environment protection rules
• In creating a custom GitHub Action to enforce coding standards across multiple projects within an organization, what strategy should be employed to allow for project-specific customizations while maintaining a common set of standards? Create a base action with common standards and allow projects to extend or override these standards through a configuration file in each project's repository.
• In creating a custom GitHub Action to enforce coding standards across multiple projects within an organization, what strategy should be employed to allow for project-specific customizations while maintaining a common set of standards? Create a base action with common standards and allow projects to extend or override these standards through a configuration file in each project's repository
• In developing a custom GitHub Action that generates and publishes reports, how should the action be designed to handle large report files to ensure efficient performance and resource usage? Store the report files externally and provide download links in the action's output., Compress the report files within the action before publishing to minimize file size.
• In developing a custom GitHub Action to integrate with a project management tool for automated task creation, how should the action be designed to customize task attributes based on different types of events in a GitHub repository? Allow users to define mappings between GitHub events and task attributes in a configuration file within their repository.
• In GitHub Actions, how can you configure a workflow to trigger only on pull requests that are opened or reopened, and additionally only when changes are made to files in a specific directory? Use the on: pull_request trigger with a types field specifying opened and reopened, combined with a paths filter including the specific directory.
• In GitHub Actions, how can you configure a workflow to trigger only on pull requests that are opened or reopened, and additionally only when changes are made to files in a specific directory? Use the on: pull_request trigger with a types field specifying opened and reopened, combined with a paths filter including the specific directory.
• In GitHub Actions, how can you dynamically generate a matrix for a job to run against multiple configurations, using data from an external JSON file hosted in the same repository? Implement a custom action that reads the JSON file and outputs the matrix configuration, then use this output in the job's matrix setting.
• In GitHub Actions, how can you effectively debug a failing job within a workflow? Insert echo commands in the workflow file to print out variable values and command outputs at various stages.
• In GitHub Actions, how can you effectively debug a failing job within a workflow? Insert echo commands in the workflow file to print out variable values and command outputs at various stages.
• In GitHub Actions, how can you ensure that a job in a workflow only runs on a specific day of the week, for instance, every Friday? Use the on: schedule syntax with a cron expression in the workflow file, such as on: schedule: - cron: '0 0 * * 5'.
• In GitHub Actions, how can you ensure that a job in a workflow only runs on a specific day of the week, for instance, every Friday? Use the on: schedule syntax with a cron expression in the workflow file, such as on: schedule: - cron: '0 0 * * 5'.
• In GitHub Actions, how can you ensure that a specific job in a workflow only runs after two other jobs have successfully completed? Implement the needs: [job1, job2] keyword in the job definition to establish a dependency on job1 and job2.
• In GitHub Actions, how can you ensure that a specific job in a workflow only runs if changes were made to files in either of two different directories? Create a preliminary job to check for changes in the specified directories and use its output in the if condition of the dependent jobs.
• In GitHub Actions, how can you ensure that a specific job in a workflow only runs if changes were made to files in either of two different directories? Create a preliminary job to check for changes in the specified directories and use its output in the if condition of the dependent jobs.
• In GitHub Actions, how can you selectively run jobs within a workflow based on the type of event that triggered the workflow? Employ the if: github.event_name == 'event_type' condition at the start of each job to specify when the job should run based on the event type.
• In GitHub Actions, how can you set up a workflow to run on both push and pullrequest events, but ensure specific jobs are executed only for pullrequest events? Configure the workflow with on: [push, pull_request] and use if: github.event_name == 'pull_request' conditionals on specific jobs.
• In GitHub Actions, how can you set up a workflow to run on both push and pullrequest events, but ensure specific jobs are executed only for pullrequest events? Configure the workflow with on: [push, pull_request] and use if: github.event_name == 'pull_request' conditionals on specific jobs.
• In GitHub Actions, how can you set up a workflow to trigger at a specific time only if there have been changes in a particular branch since the last successful run of the workflow? Configure the workflow with the on: schedule trigger and a cron expression, then use a script step to check for changes in the branch since the last run.
• In GitHub Actions, how can you utilize artifacts generated in one workflow in a separate, subsequent workflow within the same repository? Use the on: workflow_run trigger in the subsequent workflow and utilize the actions/download-artifact@v2 action to fetch the artifacts
• In GitHub Actions, how do you correctly configure a workflow to only execute a job when a previous job has failed? Use the needs keyword with if: failure() condition, like needs: job1 and if: failure() in the job definition.
• In GitHub Actions, how do you correctly configure a workflow to only execute a job when a previous job has failed? Use the needs keyword with if: failure() condition, like needs: job1 and if: failure() in the job definition.
• In GitHub Actions, how should you correctly configure a workflow to trigger only on pull requests targeting the main branch? Use on: pull_request: branches: [main] to specify that the workflow should only run for pull requests targeting the main branch.
• In GitHub Actions, how would you configure a workflow to automatically cancel previous runs of the same workflow on the same branch when a new run is triggered? Use the concurrency keyword with a unique group name that includes the branch name to automatically cancel overlapping runs.
• In GitHub Actions, how would you correctly configure a workflow to cache dependencies for a Node.js application to improve build times? Include a step with uses: actions/cache@v2 and configure the path to node_modules, along with an appropriate key based on the package-lock.json file.
• In GitHub Actions, what is the best practice for managing and sharing commonly used environment variables across multiple jobs within a workflow? Use the env keyword at the workflow level to set common environment variables for all jobs.
• In GitHub Actions, what is the best practice for managing and sharing commonly used environment variables across multiple jobs within a workflow? Use the env keyword at the workflow level to set common environment variables for all jobs.
• In GitHub Actions, what is the correct approach to ensure that a workflow is triggered by a push event only when specific files or directories change? Use the on: push: paths: ['specific-path/*'] syntax to trigger the workflow only when changes occur in files or directories under 'specific-path'.
• In GitHub Actions, what is the correct method to reuse workflows stored in a public repository in your organization's private repository? Reference the public workflow using the uses keyword with the repository's URL and path to the workflow file.
• In GitHub Actions, what is the correct method to reuse workflows stored in a public repository in your organization's private repository? Reference the public workflow using the uses keyword with the repository's URL and path to the workflow file.
• In GitHub Actions, what is the recommended approach to manage and use secrets (like API keys or passwords) in a workflow that needs to access an external service? Use GitHub's encrypted secrets feature to store and access secrets in the workflow.
• In GitHub Actions, you want to consume a workflow from another repository and trigger it whenever a new issue is opened in your repository. How can you achieve this? Use the on: repository_dispatch event in the target repository's workflow and dispatch an event from your repository when a new issue is opened.
• In the context of consuming workflows in GitHub Actions, how can you trigger a workflow in one repository as a result of an event in a separate repository? Use the on: repository_dispatch event in the consuming repository, and send a repository dispatch event from the source repository.
• In the context of consuming workflows in GitHub Actions, which of the following is a correct method to specify a dependency between jobs? Use the needs keyword in the job that depends on the completion of another job.
• In the context of creating a custom GitHub Action, what is the best approach to handle sensitive information, such as API keys or credentials, required by the action? Advise users to store sensitive information as encrypted secrets in their GitHub repository and pass them as environment variables to the action.
• In the context of GitHub Actions, what is the correct use of environment keyword in a workflow file? environment is utilized to specify the deployment environment, such as production, staging, or development, and can enforce additional rules like manual approvals.
• In the development of a custom GitHub Action, how should you handle and report errors that occur during the action's execution to ensure users of the action can effectively debug issues? Implement custom error handling in the action's code that catches and logs detailed error messages, using GitHub's logging commands for enhanced visibility.
• In the development of a custom GitHub Action, what is the most effective way to handle different runtime environments (e.g., production, staging, development) within the action's logic? Include environment-specific parameters as inputs in the action's action.yml file, allowing users to specify the environment during workflow configuration. and Utilize GitHub's environment secrets and have the action dynamically adjust its behavior based on these secrets.
• In the development of a custom GitHub Action, what is the most effective way to handle different runtime environments (e.g., production, staging, development) within the action's logic? Utilize GitHub's environment secrets and have the action dynamically adjust its behavior based on these secrets. e Include environment-specific parameters as inputs in the action's action.yml file, allowing users to specify the environment during workflow configuration.
• In the process of authoring a custom GitHub Action, what is the recommended approach to ensure that the action is compatible with both Linux and Windows runners? Develop the action using JavaScript, which is cross-platform and supported by the GitHub Actions runner environment on both Linux and Windows.
• In the process of building a custom GitHub Action that integrates with a bug tracking system to automatically create issues based on code commits, what approach should be taken to efficiently categorize and prioritize these issues? Use keywords in commit messages to determine the priority and category of issues, and configure the action to parse these keywords.
• In the process of building a custom GitHub Action that integrates with a bug tracking system to automatically create issues based on code commits, what approach should be taken to efficiently categorize and prioritize these issues? Use keywords in commit messages to determine the priority and category of issues, and configure the action to parse these keywords.
• In the process of creating a custom GitHub Action, what is the best practice for ensuring that the action remains maintainable and easy to update as GitHub Actions evolves and new features are released? Subscribe to GitHub's changelog and update the action only when necessary to maintain compatibility with the GitHub Actions platform. e Build the action with modular components, allowing for easy updates and integration of new features without major refactoring.
• In which scenario is it appropriate to use the GITHUB_TOKEN secret in a GitHub Actions workflow? When the workflow needs to interact with the GitHub API to perform actions like committing code, creating releases, or managing issues and pull requests.
• It's possible to distribute actions and workflows to multiple repositories within an enterprise by storing them in a centralized .github repository and referencing them as needed. Yes
• What accurately defines the scope of encrypted secrets in GitHub Actions? Encrypted secrets can be defined at the repository or organization level, with access limited to specific workflows.
• What are indicators that a GitHub Action is trustworthy? The action is published by a known organization, has a significant number of stars, and thorough documentation.
• What can you understand by reading a GitHub Actions workflow configuration file? The specific steps and actions that the workflow will execute, along with the events that trigger it.
• What can you understand by reading a GitHub Actions workflow configuration file? The specific steps and actions that the workflow will execute, along with the events that trigger it.
• What impact does configuring IP allow lists have on GitHub-hosted and self-hosted runners? It restricts runner access to only those IP addresses specified in the allow list, enhancing security.
• What is a best practice for distributing custom actions in GitHub Actions? Ensure the action is well-documented, including clear instructions on usage, inputs, and outputs.
• What is a best practice for distributing custom actions in GitHub Actions? Ensure the action is well-documented, including clear instructions on usage, inputs, and outputs.
• What is a best practice for maintaining self-hosted runners in GitHub Actions? Regularly update the runners' software and monitor their performance and logs
• What is a best practice for managing encrypted secrets at the repository level in GitHub Actions? Use the repository settings to add encrypted secrets that are specific to the repository.
• What is a crucial aspect of monitoring self-hosted runners in an enterprise environment? Regularly checking the status and performance metrics of runners to ensure they operate optimally.
• What is a crucial step when configuring a workflow to publish an image to the GitHub Container Registry? Authenticating with the GitHub Container Registry and pushing the image using appropriate commands within a workflow run
• What is a key consideration when creating a release strategy for a GitHub Action? Implement versioning to track changes, facilitate backward compatibility, and manage releases effectively.
• What is a key consideration when creating a release strategy for a GitHub Action? Implement versioning to track changes, facilitate backward compatibility, and manage releases effectively.
• What is a key consideration when selecting the appropriate runners to support specific workloads? Select runners based on workload requirements, such as processing power or specific software dependencies.
• What is a key difference between GitHub-hosted and self-hosted runners in GitHub Actions? GitHub-hosted runners provide a predefined environment, while self-hosted runners offer more control and customization options.
• What is a key difference between GitHub-hosted and self-hosted runners in GitHub Actions? GitHub-hosted runners provide a predefined environment, while self-hosted runners offer more control and customization options.
• What is a key step when publishing to GitHub Packages using a GitHub Actions workflow? Configure the workflow to authenticate with GitHub Packages and push the package using the appropriate command.
• What is a necessary step when configuring a GitHub Actions workflow to deploy a release to a cloud provider? Configure the workflow to authenticate with the cloud provider and use the provider's deployment tools or CLI within the workflow steps.
• What is a primary method for diagnosing a failed GitHub Actions workflow run? Checking the workflow run history and logs to identify error messages and the steps where the failure occurred.
• What is an essential aspect of defining the syntax for jobs in a GitHub Actions workflow file? Jobs should be defined with correct indentation and encapsulated within the jobs keyword.
• What is an essential step when configuring self-hosted runners for enterprise use? Configure network settings, including proxies and IP allow lists, to ensure secure and efficient operation within the enterprise environment.
• What is an essential step when publishing an action to the GitHub Marketplace? Ensure the action's repository is public and includes a README file with detailed usage instructions.
• What is an essential step when publishing an action to the GitHub Marketplace? Ensure the action's repository is public and includes a README file with detailed usage instructions.
• What is crucial for the correct syntax of jobs in a GitHub Actions workflow file? Jobs should be defined under the jobs key with proper indentation to ensure the structure is correctly interpreted.
• What is crucial for the correct syntax of jobs in a GitHub Actions workflow file? Jobs should be defined under the jobs key with proper indentation to ensure the structure is correctly interpreted.
• What is crucial to include in the action.yml file when defining a new GitHub Action? The name, description, inputs, outputs, and runs steps for the action.
• What is essential for correctly defining the syntax of jobs in a GitHub Actions workflow file? Jobs should be defined under the jobs key, with proper indentation and structure to ensure correct parsing and execution.
• What is the best practice for updating self-hosted runners? Implementing a regular update schedule to ensure runners have the latest features and security patches.
• What is the correct syntax for defining custom environment variables in a step of a GitHub Actions workflow? steps: - name: Example step run: echo "Hello world" env: CUSTOM_VAR: "value"
• What is the correct syntax for defining custom environment variables in a step of a GitHub Actions workflow? steps:- name: Example step run: echo "Hello world" env:CUSTOM_VAR: "value"
• What is the difference between disabling and deleting a workflow in GitHub Actions? Disabling a workflow stops it from being triggered but retains the workflow file in the repository, while deleting a workflow removes the file entirely.
• What is the difference between disabling and deleting a workflow in GitHub Actions? Disabling a workflow stops it from being triggered but retains the workflow file in the repository, while deleting a workflow removes the file entirely.
• What is the most effective approach for distributing actions within an enterprise? Create a centralized shared repository and utilize GitHub's internal networking features for distribution.
• What is the primary benefit of being able to move self-hosted runners into and between groups? It allows for flexible resource management and adapts to changing project needs or organizational structures.
• What is the primary benefit of configuring caching for workflow dependencies in GitHub Actions? To speed up workflow execution by reusing previously downloaded or built dependencies.
• What is the primary purpose of using CodeQL in a GitHub Actions workflow? To automatically analyze the codebase for vulnerabilities and code quality issues as part of the CI/CD process.
• What is the purpose of adding a workflow status badge to a repository? To provide a visual representation of the workflow's status (e.g., passing, failing) on the repository's README or other web pages.
• What is the purpose of adding a workflow status badge to a repository? To provide a visual representation of the workflow's status (e.g., passing, failing) on the repository's README or other web pages.
• What is the purpose of using conditional keywords in steps within a GitHub Actions workflow? To control the execution of specific steps based on the outcome of previous steps or the context of the workflow run.
• What is the purpose of using conditional keywords in steps within a GitHub Actions workflow? To control the execution of specific steps based on the outcome of previous steps or the context of the workflow run
• What is the purpose of using conditional keywords in steps within a GitHub Actions workflow? To run steps only if certain conditions are met, adding flexibility and control to the workflow.
• What is the recommended way to pass data between jobs in a GitHub Actions workflow? Use artifacts to share data between jobs, ensuring the output from one job is available to subsequent jobs.
• What is the recommended way to pass data between jobs in a GitHub Actions workflow? Use artifacts to share data between jobs, ensuring the output from one job is available to subsequent jobs.
• What is the role of approval gates in GitHub Actions workflows? To introduce manual approval steps in the workflow, allowing stakeholders to review and approve changes before they proceed.
• What is the role of CodeQL when used as a step in a GitHub Actions workflow? To automatically analyze the codebase for vulnerabilities and code quality issues.
• What is the role of implementing workflow commands as a run step in a GitHub Actions workflow? To communicate with the runner, setting environment variables or altering the workflow behavior.
• What should be considered when configuring self-hosted runners for enterprise use? Configure networking, proxies, and labels appropriately to adhere to enterprise policies and infrastructure.
• When assessing the trustworthiness of a GitHub Action, what should you look for? The action has positive reviews, is maintained actively, and the source code is publicly available for review.
• When authoring a custom GitHub Action that integrates with an external API, how should you handle potential API rate limits to prevent disruptions in user workflows? Implement logic in the action to detect rate limit errors and automatically retry the request after a sensible delay AND Provide an option for users to input their own API keys, allowing them to manage their rate limits independently.
• When authoring a custom GitHub Action that integrates with an external API, how should you handle potential API rate limits to prevent disruptions in user workflows? Provide an option for users to input their own API keys, allowing them to manage their rate limits independently. AND Implement logic in the action to detect rate limit errors and automatically retry the request after a sensible delay.
• When authoring a custom GitHub Action to be used across multiple projects within an organization, what is the best practice for handling updates to the action to minimize disruptions in those projects? Release new versions of the action using version tags, and instruct projects to use specific versions rather than the latest commit on the main branch.
• When authoring a custom GitHub Action, what is the best practice for managing and versioning the action to ensure stability and ease of maintenance for users? Create specific releases or tags for stable versions of the action, and advise users to reference these in their workflows.
• When authoring a JavaScript-based custom GitHub Action, what is the recommended approach to manage third-party dependencies that the action requires? Bundle the dependencies with a tool like Webpack, and commit the bundled file along with your action code to the repository.
• When authoring and maintaining workflows in GitHub Actions, which of the following statements is accurate? Workflows are defined in YAML files and should be placed in the .github/workflows directory of the repository
• When authoring and maintaining workflows in GitHub Actions, which statement is correct regarding the use of jobs..strategy in a workflow file? Within strategy, the matrix keyword can be used to run tests across multiple versions of a language or operating system.
• When configuring IP allow lists for GitHub-hosted and self-hosted runners, what is the primary effect? It restricts which IP addresses can interact with your runners, enhancing security.
• When consuming workflows in GitHub Actions, how can you ensure that a workflow is triggered only when a new release is published in another repository within the same organization? Configure a repository_dispatch event in the source repository and trigger it manually when a new release is published.
• When creating a custom GitHub Action in a public repository, what is the best practice for ensuring the action's code adheres to consistent coding standards and best practices? Implement a linter in the action's development workflow to automatically check code submissions for adherence to defined coding standards.
• When creating a custom GitHub Action in a public repository, what is the best practice for ensuring the action's code adheres to consistent coding standards and best practices? Implement a linter in the action's development workflow to automatically check code submissions for adherence to defined coding standards.
• When creating a custom GitHub Action that integrates with third-party services, what approach should be adopted to handle service outages or downtime to ensure minimal impact on workflow execution? Implement retry logic in the action to attempt reconnection to the third-party service a set number of times before failing., Provide users with the option to skip steps dependent on the third-party service during outages, through input parameters in the action.
• When creating a custom GitHub Action that integrates with third-party services, what approach should be adopted to handle service outages or downtime to ensure minimal impact on workflow execution? Implement retry logic in the action to attempt reconnection to the third-party service a set number of times before failing. e Provide users with the option to skip steps dependent on the third-party service during outages, through input parameters in the action.
• When creating a custom GitHub Action that is expected to evolve and scale over time, how should version control and release management be handled to ensure backward compatibility and minimize disruption for users? Implement semantic versioning for the action, using tags to mark stable release versions, and instruct users to reference specific versions.
• When designing a custom GitHub Action to automatically update documentation based on code changes, what is the best approach to ensure that the documentation remains synchronized with the codebase across different branches? Trigger the action on every push event across all branches, ensuring documentation updates occur in parallel with code changes. AND Implement logic in the action to detect code changes that affect documentation and update relevant branches accordingly.
• When designing a custom GitHub Action to facilitate code reviews by automatically assigning reviewers based on the type of changes made, what method should be used to determine the most appropriate reviewers for each pull request? Use a configuration file in the repository that maps specific types of changes to relevant reviewers, allowing for easy updates and customization.
• When developing a composite run steps action in GitHub Actions, what is the recommended way to include external scripts or code files that the action depends on? Include the external scripts or code files in the same repository as the action and reference them using relative paths in the runs.steps entries.
• When developing a custom Docker-based GitHub Action, what is the recommended method for passing input parameters from the workflow to the Docker container? Define input parameters in the action's metadata file (action.yml) and access them as environment variables inside the Docker container.
• When developing a custom GitHub Action for automating dependency updates in a multi-language project environment, what is the most efficient approach to handle updates across different programming languages and package managers? Implement a modular action with plug-ins or scripts for each language and package manager, allowing the action to be extended as needed.
• When developing a custom GitHub Action for code analysis and linting, how can you best ensure that the action remains up-to-date with the latest coding standards and practices in a rapidly evolving programming language ecosystem? Allow users to specify their own set of rules or link to an external ruleset in their workflow configuration. E Integrate the action with a popular, actively maintained linting tool or library, automatically updating to the latest version on each run.
• When developing a custom GitHub Action for code analysis and linting, how can you best ensure that the action remains up-to-date with the latest coding standards and practices in a rapidly evolving programming language ecosystem? Integrate the action with a popular, actively maintained linting tool or library, automatically updating to the latest version on each run. AND Allow users to specify their own set of rules or link to an external ruleset in their workflow configuration.
• When developing a custom GitHub Action that interacts with external APIs, what is the best strategy to manage and rotate API keys or tokens to enhance security? Store the API keys or tokens as encrypted secrets in the GitHub repository and reference them in the action's code.
• When developing a custom GitHub Action that involves complex computational tasks, what is the best approach to optimize performance and reduce execution time? Implement caching mechanisms in the action to store and reuse computational results where possible. AND Offload the computational tasks to an external server or cloud service, and have the action interact with that service.
• When developing a custom GitHub Action that involves complex computational tasks, what is the best approach to optimize performance and reduce execution time? Offload the computational tasks to an external server or cloud service, and have the action interact with that service. and Implement caching mechanisms in the action to store and reuse computational results where possible.
• When diagnosing a failed GitHub Actions workflow run, which of the following steps are appropriate? Review the workflow run history to identify patterns or recurring issues. AND Use GitHub's REST API to programmatically fetch logs for the failed workflow run.
• When implementing a GitHub Actions workflow, how can you conditionally skip a job unless a manual trigger is activated, such as a comment in a pull request? Use the on: issue_comment trigger combined with a job-level if condition checking the comment content.
• When implementing a GitHub Actions workflow, how can you conditionally skip a job unless a manual trigger is activated, such as a comment in a pull request? Use the on: issue_comment trigger combined with a job-level if condition checking the comment content.
• When implementing workflow commands within an action to communicate with the runner, what is important to consider? Always use exit codes to communicate the status of the action to the runner.
• When managing and publishing GitHub Actions, which of the following practices are recommended? Provide comprehensive documentation, including usage instructions, input and output descriptions, and example workflows. AND Regularly update and maintain your actions, ensuring they are compatible with the latest GitHub features and security standards. AND Use clear and descriptive naming conventions for your actions and repositories.
• When managing and publishing GitHub Actions, which of the following practices are recommended? Regularly update and maintain your actions, ensuring they are compatible with the latest GitHub features and security standards. and Use clear and descriptive naming conventions for your actions and repositories. AND Provide comprehensive documentation, including usage instructions, input and output descriptions, and example workflows.
• When managing repository-level encrypted secrets, what is an important practice? Secrets should be scoped to specific environments or branches, limiting access where necessary.
• When managing repository-level encrypted secrets, what is an important practice? Secrets should be scoped to specific environments or branches, limiting access where necessary.
• When managing runners for an enterprise, which of the following practices should be implemented? Select runners based on the specific workload requirements, including the necessary operating system and hardware needs. AND Regularly monitor, troubleshoot, and update self-hosted runners to ensure they are secure and functioning optimally. AND Configure IP allow lists to control access to both GitHub-hosted and self-hosted runners.
• When setting up a CI/CD pipeline, how should you select the appropriate runners to support your workloads? Choose runners based on the workload requirements, such as the necessary operating system or specific hardware needs.
• When setting up a GitHub Actions workflow, how can you ensure that a job is only executed if a previous job in the workflow has failed? Use the if: failure() condition combined with the needs keyword, like needs: [previous_job] and if: failure() in the job definition.
• When setting up a GitHub Actions workflow, how can you ensure that a job is only executed if a previous job in the workflow has failed? Use the if: failure() condition combined with the needs keyword, like needs: [previous_job] and if: failure() in the job definition.
• When troubleshooting a Docker container action in a GitHub Actions workflow, you notice that the action fails to start. Which of the following steps should you take first? Check the Dockerfile for any syntax errors or missing dependencies.
• When working with encrypted secrets in GitHub Actions, what determines the scope of an encrypted secret? Whether the secret is stored at the organization level or the repository level.
• Where can custom environment variables be set in a GitHub Actions workflow? In the env key at the workflow, job, or step level.
• Where can you access the logs of a GitHub Actions workflow run from the GitHub user interface? In the 'Actions' tab of the repository, by selecting the specific workflow run.
• Where can you locate a workflow file in a GitHub repository? In the .github/workflows directory at the root of the repository.
• Where should sensitive information, such as access tokens and passwords, be stored when configuring GitHub Actions workflows? As encrypted secrets, which can be accessed in the workflow via the secrets context.
• Which aspect is least likely to contribute to the trustworthiness of an action listed on the GitHub Marketplace? The action is published by an individual with no prior contributions to open source.
• Which configuration allows a workflow to be triggered by multiple events in GitHub Actions? Use the on keyword to specify a list of events, like push, pull_request, and schedule.
• Which configuration allows a workflow to be triggered by multiple events in GitHub Actions? Use the on keyword to specify a list of events, like push, pull_request, and schedule
• Which event configuration correctly triggers a workflow in GitHub Actions? Using the on keyword in the workflow file to specify the type of event, such as push, pull_request, or schedule.
• Which event configuration correctly triggers a workflow in GitHub Actions? Using the on keyword in the workflow file to specify the type of event, such as push, pull_request, or schedule.
• Which method can be used to access the logs of a GitHub Actions workflow run using GitHub's REST API? Send a GET request to the appropriate endpoint with the workflow run ID to retrieve the logs.
• Which method can be used to access the logs of a GitHub Actions workflow run using GitHub's REST API? Send a GET request to the appropriate endpoint with the workflow run ID to retrieve the logs.
• Which of the following are advanced configurations in GitHub Actions workflows? Adding environment protections to ensure workflows run only in safe, approved contexts., Defining a matrix of different job configurations to test across multiple environments. and Removing workflow artifacts after a certain period to manage storage and maintain cleanliness.
• Which of the following are advanced configurations in GitHub Actions workflows? Removing workflow artifacts after a certain period to manage storage and maintain cleanliness. AND Adding environment protections to ensure workflows run only in safe, approved contexts AND Defining a matrix of different job configurations to test across multiple environments.
• Which of the following are benefits of reusing templates for actions and workflows in GitHub Actions? (Choose 2) Significantly reduces the time required for onboarding new team members., Ensures consistency and best practices across multiple projects.
• Which of the following are best practices for managing encrypted secrets in GitHub Actions? Regularly rotate secrets to minimize the risk of exposure., Use environment-specific secrets to tailor access based on deployment stages. and Audit access to secrets and review usage in workflows regularly.
• Which of the following are best practices for managing encrypted secrets in GitHub Actions? Use environment-specific secrets to tailor access based on deployment stages., Audit access to secrets and review usage in workflows regularly., Regularly rotate secrets to minimize the risk of exposure.
• Which of the following are components of a GitHub Actions workflow? Conditional keywords that control the execution of jobs and steps based on certain conditions. AND Jobs, which group together individual steps that run as part of the workflow. AND Steps, which represent individual tasks like running a script or an action.
• Which of the following are effective troubleshooting steps for self-hosted runners? (Choose 2) Verifying network connectivity and access controls., Reviewing logs for error messages or warnings.
• Which of the following are true regarding the components and integration of actions, workflows, jobs, steps, runs, and the marketplace in GitHub Actions? Marketplace is a platform where pre-built actions can be published and used within workflows without custom coding., Conditional keywords can be used in steps to control their execution based on certain conditions. and Workflows are automated processes defined by jobs, which in turn consist of steps that can include actions or shell commands.
• Which of the following are true regarding the components and integration of actions, workflows, jobs, steps, runs, and the marketplace in GitHub Actions? Workflows are automated processes defined by jobs, which in turn consist of steps that can include actions or shell commands., Marketplace is a platform where pre-built actions can be published and used within workflows without custom coding. e Conditional keywords can be used in steps to control their execution based on certain conditions.
• Which of the following are valid steps to troubleshoot a JavaScript action in a GitHub Actions workflow? Examine the action's documentation for any known issues or requirements. AND Check the package.json file to ensure all dependencies are correctly listed and versions are compatible. AND Review the workflow logs for any error messages or indications of where the process is failing.
• Which of the following is a best practice for managing and leveraging reusable components in an enterprise setting? Utilize a dedicated repository for storage and establish clear naming conventions for files and folders.
• Which of the following statements are correct regarding the use of environment variables in GitHub Actions workflows? Default environment variables provide predefined context about the workflow run, like the branch name or commit SHA., Custom environment variables can be set at the workflow, job, or step level using the env keyword. and The GITHUB_ENV workflow command can be used to set environment variables for subsequent steps in a job.
• Which of the following statements are correct regarding the use of environment variables in GitHub Actions workflows? The GITHUB_ENV workflow command can be used to set environment variables for subsequent steps in a job. AND Default environment variables provide predefined context about the workflow run, like the branch name or commit SHA AND Custom environment variables can be set at the workflow, job, or step level using the env keyword.
• Which option correctly configures a GitHub Actions workflow to run for multiple events? Use the on keyword in the workflow file to list multiple events like push, pull_request, and schedule.
• Which statement accurately describes the difference between GitHub-hosted and self-hosted runners? GitHub-hosted runners are fully managed by GitHub, offering convenience but less control over the environment.
• Which statement accurately describes the difference between GitHub-hosted and self-hosted runners? GitHub-hosted runners are fully managed by GitHub, offering convenience but less control over the environment.
• You are an administrator for your GitHub organization and need to make a secret available to multiple repositories. How do you manage this secret? Store the secret at the organization level and grant access to the required repositories.
• You are creating a new GitHub Action. What is the necessary file and directory structure you should set up? A directory at the root of the repository containing a Dockerfile or a JavaScript file, and an action.yml file.
• You are creating a new GitHub Action. What is the necessary file and directory structure you should set up? A directory at the root of the repository containing a Dockerfile or a JavaScript file, and an action.yml file.
• You are creating a workflow and want to include the branch name that triggered the workflow run in the job. Which default environment variable should you use? GITHUBREFNAME
• You are drafting organizational use policies for GitHub Actions. Which of the following should be included in your policies? Implement monitoring and auditing mechanisms to track the usage and performance of actions. , Define clear guidelines on the creation, sharing, and usage of GitHub Actions within the organization. e Regularly review and update actions to ensure compliance with security standards and best practices.
• You are integrating a new action into your workflow. How can you identify the action's type, required inputs, and expected outputs? By reading the action's README.md file and the action metadata file (action.yml or action.yaml).
• You are integrating a new action into your workflow. How can you identify the action's type, required inputs, and expected outputs?By reading the action's README.md file and the action metadata file (action.yml or action.yaml).
• You are managing a set of self-hosted runners for your enterprise on GitHub Actions. How can you effectively manage access and organize these runners? Create groups for runners and assign runners to groups based on usage or department needs.
• You are managing GitHub Actions workflows in your organization's repositories. Which of the following practices should you follow? Use encrypted secrets to store and access sensitive information like API keys and passwords in workflows., Review and integrate updates to actions cautiously, ensuring they do not break existing workflows. and Regularly review and update the actions used in your workflows to ensure they receive security updates and improvements.
• You are managing GitHub Actions workflows in your organization's repositories. Which of the following practices should you follow? Use encrypted secrets to store and access sensitive information like API keys and passwords in workflows.
• You are managing secrets for a specific repository in your organization. What should you consider when creating repository-level encrypted secrets? Repository-level secrets are best for sensitive data specific to one repository and are not accessible by other repositories.
• You are managing secrets for a specific repository in your organization. What should you consider when creating repository-level encrypted secrets? Repository-level secrets are best for sensitive data specific to one repository and are not accessible by other repositories.
• You are planning to release a series of updates for your GitHub Action. What approach should you take to create an effective release strategy? Use semantic versioning to tag releases, providing clear information about the nature of each update.nnels.
• You are responsible for ensuring that GitHub Actions are used securely and appropriately within your enterprise. How can you control access to these actions? Implement role-based access controls at the organization level and integrate with the enterprise's identity management system.
• You are responsible for ensuring that GitHub Actions are used securely and appropriately within your enterprise.How can you control access to these actions? Implement role-based access controls at the organization level and integrate with the enterprise's identity management system.
• You are reviewing a GitHub Actions workflow and encounter an action defined in the workflow file. How can you identify the type of action used (e.g., JavaScript, Docker container, or composite)? By checking the runs section in the action's action.yml or action.yaml file.
• You are setting up a CI/CD pipeline for a project that requires a specific operating system. How should you select an appropriate runner? Choose a GitHub-hosted runner that supports the required operating system.
• You are setting up encrypted secrets for your projects. How does the scope of encrypted secrets differ between organization-level and repository-level in GitHub Actions? Organization-level secrets can be made available to multiple repositories, while repository-level secrets are accessible only to the repository they are set in.
• You are setting up encrypted secrets for your projects. How does the scope of encrypted secrets differ between organization-level and repository-level in GitHub Actions? Organization-level secrets can be made available to multiple repositories, while repository-level secrets are accessible only to the repository they are set in.
• You are tasked with creating a new custom GitHub Action for your organization's workflow. What metadata and syntax are essential to define in the action's configuration file for it to function correctly? An action.yml or action.yaml file containing the metadata and inputs, outputs, and runs sections.
• You have two GitHub repositories: Repository A and Repository B. You want to configure a workflow in Repository A to automatically trigger whenever a new pull request is created in Repository B. What is the best way to set up this integration? Configure a webhook in Repository B to trigger a repository_dispatch event in Repository A whenever a pull request is created.
• You need to programmatically retrieve the logs of a specific GitHub Actions workflow run. How can you achieve this? Use GitHub's REST API and send a GET request to the appropriate endpoint with the workflow run ID.
• You need to reorganize your self-hosted runners due to changes in project allocations. How can you move a runner from one group to another? Use GitHub's runner management interface to reassign the runner to a different group.
• You notice that a workflow was triggered and completed a series of tasks in your repository. How can you identify the event that triggered this workflow? Examine the GITHUB_EVENT_NAME environment variable in the workflow run logs to see the type of event that triggered the workflow.
• You want to ensure stability in your workflows by using a specific version of an action. How can you correctly reference a specific version of an action in your workflow file? By using the action's name followed by the @ symbol and the version tag or commit SHA (e.g., actions/checkout@v2).
• You want to ensure stability in your workflows by using a specific version of an action. How can you correctly reference a specific version of an action in your workflow file? By using the action's name followed by the @ symbol and the version tag or commit SHA (e.g., actions/checkout@v2). AND
• You want to ensure that specific GitHub Actions are only used by authorized personnel within your organization. What's an effective way to achieve this? Implement role-based access controls and integrate with the organization's identity management system.
• You want to ensure that specific GitHub Actions are only used by authorized personnel within your organization. What's an effective way to achieve this? Implement role-based access controls and integrate with the organization's identity management system.
• You're maintaining a repository and decide that a particular workflow is not needed for the next two months, but it might be useful later. What action would you take? Disable the workflow to temporarily stop it from being triggered
• You've developed a custom GitHub Action for automating deployments. Your action is likely to be beneficial to other projects outside your organization. How should you distribute your action? Publish the action to the GitHub Marketplace to make it publicly available.
• You've developed a custom GitHub Action for automating deployments. Your action is likely to be beneficial to other projects outside your organization. How should you distribute your action? Publish the action to the GitHub Marketplace to make it publicly available.
• You've finalized a new GitHub Action that automates code quality checks. How can you publish this action to the GitHub Marketplace? Create a public repository for the action, release it using tags, and then publish it through the marketplace section in your repository settings.
• You've just fixed a bug in your application and the CI workflow has run successfully, generating test reports as artifacts. How would you download these artifacts from the GitHub user interface? Navigate to the Actions tab, select the specific workflow run, and find the Artifacts section to download the reports.
• Your enterprise requires a secure and efficient method to distribute GitHub Actions across multiple teams. What is the best approach? Create a centralized shared repository for actions and enforce access controls.
• Your enterprise requires a secure and efficient method to distribute GitHub Actions across multiple teams. What is the best approach? Create a centralized shared repository for actions and enforce access controls.
• Your enterprise requires a systematic approach to distributing GitHub Actions across various teams. What is the most effective strategy? Develop a private, centralized repository for actions and manage access using GitHub's built-in permission system.
• Your organization has a standard workflow template for CI/CD that you want to use in your new project. How do you apply this template to your project's repository? Select the templated workflow from your repository's Actions tab and customize it if necessary.
• Your organization has stringent security requirements. What would be the effect of configuring IP allow lists on GitHub-hosted and self-hosted runners? It restricts network access, allowing only traffic from specified IP addresses to interact with the runners.
• Your organization has stringent security requirements. What would be the effect of configuring IP allow lists on GitHub-hosted and self-hosted runners? It restricts network access, allowing only traffic from specified IP addresses to interact with the runners.
• Your organization wants to ensure that only specific teams have access to certain self-hosted runners. How can you manage access effectively? Use GitHub's runner management interface to set access permissions for each runner group.
• Your organization wants to ensure that only specific teams have access to certain self-hosted runners. How can you manage access effectively? Use GitHub's runner management interface to set access permissions for each runner group.
• Your team frequently creates new repositories and wants to standardize the CI/CD process.What's the most effective way to achieve this with GitHub Actions? Utilize workflow templates stored in a designated .github repository and reference them in new repositories.
• Your team has developed a GitHub Action that contains sensitive business logic specific to your organization's internal processes. You want to ensure that this action is not accessible outside of your organization. Which distribution model should you select for this action? Store the action in a private repository within your organization and manage access through repository permissions.
• Your team needs to execute a series of shell commands as part of your CI/CD pipeline to set up the environment before deploying your application. Which type of action should you use in your GitHub Actions workflow to accomplish this task? A run step that directly executes the shell commands in the runner's environment.
• Your team wants to standardize CI/CD processes across multiple projects. How can workflow and action templates be reused effectively? Use a centralized .github repository to store workflow templates and reference them in individual project repositories.
• Your team wants to standardize CI/CD processes across multiple projects. How can workflow and action templates be reused effectively? Use a centralized .github repository to store workflow templates and reference them in individual project repositories.

UDEMY

• Why is it important to avoid passing secrets between processes from the command line? passing secrets through the command line may expose them to other users and security audits

• Your team manages its own infrastructure costs using a chargeback model and wants to ensure that development workflows do not utilize the runners paid for by your team. Which GitHub Actions feature can help achieve this goal? runner groups

• How many PowerShell commands are executed on the Windows runner with the following workflow configuration? 3 - The workflow configuration consists of two steps that execute PowerShell commands. The first step installs the PSScriptAnalyzer module using two PowerShell commands: Set-PSRepository and Install-Module. The second step retrieves a list of rules using the Get-ScriptAnalyzerRule command. Therefore, a total of 3 PowerShell commands are executed on the Windows runner in this workflow.

• How many jobs will be executed in the following workflow? 6 - The workflow defines a matrix job with two axes: 'animal' with values [cat, dog, bear] and 'color' with values [black, brown]. This results in a total of 3 (animal) x 2 (color) = 6 different combinations. Each combination will result in a separate job execution, hence a total of 6 jobs will be executed in this workflow.

• Which of the following statements accurately describes the syntax rules for indentation in YAML used for defining workflow jobs in GitHub Actions? YAML allows significant newlines and indentation, similar to Python, but unlike Python, it prohibits the use of literal tab characters for indentation

• When creating a custom action for GitHub Actions, which of the following files are required? (select three) Dockerfile for containerized actions, main.js or index.js for JavaScript actions e action.yml or action.yaml for action metadata

• As the lead developer of the GitHub Action library, you are concerned about the reliability of versioning using tags. What is a recommended alternative to ensure consistency and security in versioning? implement commit SHAs for versioning to ensure reliability and security - Implementing commit SHAs for versioning provides a reliable and secure alternative to using tags. Commit SHAs uniquely identify each commit in the repository, ensuring consistency and security in versioning. By referencing commit SHAs, you can track changes accurately and avoid potential issues that may arise from using tags.

• What is required to manually run a private repository's workflow using the GitHub REST API? Personal Access Token - A Personal Access Token is required to authenticate and authorize API requests when running a private repository's workflow using the GitHub REST API. This token acts as a substitute for your GitHub password and provides a secure way to access GitHub resources without compromising your actual password.

• After creating a new workflow, GitHub Actions will suggest starter workflows for your repository. What option should you click on if there is a starter workflow that you want to use? Configure - Clicking on "Configure" will allow you to customize and set up the suggested starter workflow for your repository. This option enables you to tailor the workflow to fit the specific requirements of your project before using it.

• Why does GitHub recommend using variables to access the filesystem instead of hardcoded file paths? variables provide a dynamic way to adapt to different runner environments - Using variables to access the filesystem allows for a more dynamic approach, enabling workflows to adapt to different runner environments seamlessly. This flexibility is crucial for ensuring consistent behavior across various environments and configurations.

• Which YAML keyword is used to specify the events that should trigger a workflow? on - The YAML keyword "on" is used to specify the events that should trigger a workflow in GitHub Actions. This keyword allows you to define the specific events, such as push, pull request, schedule, or other custom events, that will cause the workflow to run.

• What additional steps does GitHub add to each job in a workflow run? "Set up job" and "Complete job" GitHub adds the "Set up job" step at the beginning of each job to prepare the environment and set up any necessary configurations. The "Complete job" step is added at the end of the job to finalize any actions or clean up resources used during the job execution

• Your organization uses various custom actions and scripts within GitHub Actions workflows across projects. To enhance collaboration and manage components, which file and folder naming convention approach would be most beneficial? implement and enforce an organization-wide naming convention that clearly identifies the component type, purpose, and version

• What is the primary purpose of custom labels in GitHub Actions for self-hosted runners? routing jobs to specific types of self-hosted runners based on their labels - Custom labels in GitHub Actions are primarily used for routing jobs to specific types of self-hosted runners based on their labels. This allows for better resource management and optimization by ensuring that jobs are executed on the most suitable runners based on their capabilities and configurations.

• Which of the following events can trigger workflows? (select three) when a commit is pushed to the repository - When a commit is pushed to the repository, it can trigger workflows in GitHub Actions. This event is essential for automating tasks such as running tests, building the project, or deploying changes after a code commit.

• You are building a new custom action and must pass data from one step to subsequent steps in a GitHub Actions workflow. Which key should you use in the action's metadata syntax? outputs - The correct key to use in the action's metadata syntax for passing data from one step to subsequent steps in a GitHub Actions workflow is 'outputs'. This key allows you to define output parameters in your custom action that can be used by other steps in the workflow.

• What is the GITHUB_TOKEN secret used for in a workflow? to authenticate on behalf of GitHub Actions - The GITHUB_TOKEN secret is used to authenticate GitHub Actions when they interact with the GitHub API on behalf of the workflow. It provides the necessary permissions for actions to perform tasks such as checking out code, pushing code changes, creating issues, and more.

• You have created a GitHub Action that requires a specific Linux operating system and custom tools to run. What type of action is best suited for this environment? Docker container action - Docker container actions are best suited for environments that require specific operating systems and custom tools. By using a Docker container, you can package all the necessary dependencies and tools within the container, ensuring that the action runs consistently across different environments without the need for manual setup.

• Which API does GitHub Actions use to output statuses, results, and logs for a workflow? Checks API - The Checks API is the correct choice because GitHub Actions use this API to output statuses, results, and logs for a workflow. It allows workflows to create detailed status checks, annotations, and summaries for each job and step in the workflow, providing visibility into the execution and results of the workflow.

• You're developing a custom GitHub Action for your organization's CI/CD pipeline. You're considering how to manage versioning for your action. Which practice aligns best with industry standards and simplifies version control? implement semantic versioning for your tag version to clearly communicate changes and maintain compatibility - Implementing semantic versioning for your custom GitHub Action is the best practice as it clearly communicates changes and maintains compatibility with existing workflows. Semantic versioning follows a structured format (major.minor.patch) to indicate the significance of changes, making it easier for users to understand the impact of updates.

• What information is essential when drafting a new release and publishing an action to GitHub Marketplace? the action's metadata file's category must match an existing GitHub Marketplace category - When drafting a new release and publishing an action to GitHub Marketplace, it is essential that the action's metadata file's category matches an existing GitHub Marketplace category. This ensures that the action is listed in the correct category for users to discover and use effectively.

• You want to limit the use of public actions and reusable workflows so that people can only use reusable workflows in your enterprise. Where would this be configured? In the Policies section for the targeted enterprise for your organization - Configuring the limitation of public actions and reusable workflows to only be used within your enterprise would be done in the Policies section for the targeted enterprise for your organization. This setting allows you to define and enforce specific policies and restrictions related to GitHub Actions usage within your organization.

• What happens if a job is not approved within 30 days while awaiting review in a workflow? the job will automatically fail - If a job is not approved within 30 days while awaiting review in a workflow, the job will automatically fail as the approval process has not been completed within the specified timeframe. This ensures that the workflow does not get stuck indefinitely and allows for proper handling of job statuses.

• What is the filename of the metadata file that defines the inputs, outputs, and runs configuration for your action? action.yaml - The filename "action.yaml" is correct because it is the standard filename for the metadata file that defines the inputs, outputs, and runs configuration for a GitHub Action. This file is essential for configuring and defining the behavior of the action within a repository.

• What functionality does a composite action offer in GitHub Actions? combining multiple workflow steps into one action for streamlined execution - Composite actions in GitHub Actions allow users to combine multiple workflow steps into a single reusable action. This helps streamline the execution of workflows by encapsulating complex logic or repeated steps into a single unit, making workflows easier to read and maintain.

• How can encrypted secrets be accessed within actions and workflows for GitHub Actions? using the secrets context within GitHub Actions, which allows encrypted secrets to be accessed as environment variables - The correct way to access encrypted secrets within actions and workflows for GitHub Actions is by using the secrets context within GitHub Actions. This context allows encrypted secrets to be accessed as environment variables, providing a secure and convenient method for utilizing sensitive information in workflows.

• You are trying to run a new Docker container action but getting a permission denied error when running the entrypoint.sh script. How can you resolve this? modify the entrypoint.sh script to explicitly set executable permissions before running - Modifying the entrypoint.sh script to explicitly set executable permissions before running will resolve the permission denied error. By setting the executable permissions, the script will be allowed to run as intended within the Docker container action.

• What are valid ways to specify the version of the checkout action within a GitHub workflow configuration? (select three) - uses: actions/checkout@main , - uses: actions/checkout@v4, - uses: actions/checkout@8f4b7f84864484a7bf31766abe9204da3cbe65b3

• What status should you filter on to see only failed workflow runs on the GitHub Actions tab? failure - Filtering on "failure" will show only the workflow runs that have failed specifically. This is the correct status to filter on if you want to see only the failed workflow runs on the GitHub Actions tab.

• In the context of actions and workflows, what roles do steps play in the overall process? they represent individual tasks within a job - Steps in GitHub Actions represent individual tasks within a job. Each step defines a specific action to be executed, such as checking out code, running tests, or deploying an application. By breaking down the job into smaller, manageable tasks, steps help streamline the workflow process and ensure efficient execution.

• What directory is used to store workflow files within a code repository? .github/workflows - The correct directory to store workflow files within a code repository for GitHub Actions is ".github/workflows". This directory structure is the standard convention recommended by GitHub for organizing workflow files, making it easier to locate and manage them within the repository.

• Ryan is looking for the GitHub Actions workflow files for his repository. Where should he look? the .github/workflows directory of the repository - The correct location to find GitHub Actions workflow files within a repository is the .github/workflows directory. This directory is the standard location where GitHub looks for workflow files to execute when triggered by events.

• Which configuration is appropriate for triggering a workflow on a pull request? on: pull_request: branches: - main - This configuration is correct as it specifies that the workflow should be triggered on a pull request specifically for the 'main' branch. This ensures that the workflow runs when a pull request is opened, updated, or synchronized for the 'main' branch

• What capability does GitHub provide to enable runners to download actions from internal or private repositories, ensuring access control and security? GitHub creates a scoped installation token with read access to the repository, automatically expiring after one hour - GitHub provides runners with a scoped installation token that has read access to the repository where the actions are stored. This token is automatically generated and expires after one hour, ensuring access control and security by limiting the duration of access to the actions.

• How can the retention period for artifacts be customized? custom retention periods can be defined for individual artifacts using the actions/upload-artifact action - GitHub Actions allows users to customize the retention period for artifacts by defining custom retention periods for individual artifacts using the actions/upload-artifact action. This feature enables users to manage artifact storage efficiently by specifying how long each artifact should be retained before being automatically removed.

• Which keyword is used to conditionally execute a step based on a specific expression or condition? if - The 'if' keyword is used in GitHub Actions to conditionally execute a step based on a specific expression or condition. It allows you to define when a step should run based on the result of the expression provided.

• Your organization uses a self-hosted runner deployed within a network that requires a proxy server for internet access. Which environment variable should you configure on the runner to ensure it can successfully communicate with GitHub? https_proxy - Thehttps_proxyenvironment variable should be configured on the self-hosted runner to specify the proxy server that should be used for HTTPS requests. This ensures that the runner can successfully communicate with GitHub over HTTPS through the proxy server.

• What is the primary purpose of caching dependencies in a GitHub Actions workflow? decrease network utilization, runtime, and cost - Caching dependencies in a GitHub Actions workflow helps decrease network utilization, runtime, and cost by storing and reusing dependencies that have already been downloaded or built. This reduces the need to fetch dependencies from external sources repeatedly, leading to faster workflow execution and lower costs associated with data transfer and processing.

• How can you ensure a script file in your repository is executable in a workflow job? by manually granting execute permissions to the script file on the runner - By manually granting execute permissions to the script file on the runner, you ensure that the script can be executed during the workflow job. This approach involves changing the file permissions to allow the script to run as an executable file.

• Which of the following are true about Javascript actions? (select three) You can speed up development by using the GitHub Actions toolkit, Javascript actions run directly on the runner and will use existing binaries e Javascript actions can run on Linux, Windows, or macOS runners

• You're using ephemeral runners in containers for your GitHub Actions workflows. However, you've noticed that these runners repeatedly update whenever a new runner version is released, causing disruptions. What action can you take to address this issue? disable automatic updates to have manual control over updating the runner version on the container image - Disabling automatic updates will give you manual control over when to update the runner version on the container image. This way, you can plan and schedule updates during less critical times to avoid disruptions in your workflows.

• When the workflow below is triggered, what will the Print name step evaluate to? Hello My Action. We are currently running the Build job. Using Java Version 11 - This choice is correct because it correctly evaluates the environment variables and prints the values of NAME, BUILD, and JAVA_VERSION. The output will be "Hello My Action. We are currently running the Build job. Using Java Version 11".

• How should you demonstrate creating a release strategy for a GitHub Action? by defining a release-management strategy and documenting major version updates, critical fixes, and security patches - Defining a release-management strategy and documenting major version updates, critical fixes, and security patches is the correct approach to creating a release strategy for a GitHub Action. This ensures transparency, helps users understand the significance of updates, and allows for effective communication of changes. Versioning is crucial for managing dependencies and ensuring compatibility with different workflows.

• What are the requirements to publish an action to the GitHub Marketplace? the action must be in a public repository - To publish an action to the GitHub Marketplace, the action must be in a public repository. This allows other users to discover and use the action through the Marketplace.

• In a private repository, why are workflow badges not accessible externally? to prevent external embedding or linking from unauthorized sources. - Workflow badges in private repositories are not accessible externally to prevent unauthorized embedding or linking from external sources. This helps maintain the security and privacy of the repository by restricting access to only authorized users.

• Dave is building a workflow configuration that includes a reference to a filesystem path. What is the best practice for referencing a filesystem within a workflow configuration? use environment variables to reference the filesystem - Using environment variables to reference the filesystem path in a workflow configuration is a best practice as it allows for flexibility and portability. By using environment variables, the path can be easily changed or customized without having to modify the workflow configuration itself, making it more maintainable and adaptable to different environments.

• You have developed a new GitHub Action and want to share it with the greater community. Where should you publish it? GitHub Marketplace - GitHub Marketplace is the official platform where developers can share their GitHub Actions with the broader community. Publishing your GitHub Action on GitHub Marketplace makes it easily discoverable by other users and allows for seamless integration into their workflows.

• Which default environment variables cannot be overwritten using the GITHUB_ENV file in a workflow? GITHUB_* and RUNNER_* - The default environment variables starting with "GITHUB_" and "RUNNER_" cannot be overwritten using the GITHUB_ENV file in a workflow. These variables are reserved and cannot be modified to maintain the integrity and security of GitHub Actions workflows.

• GitHub Packages is compatible with the following package managers: (select three) NuGet, the .NET package manager, Maven and Gradle, two package managers for Java e npm, a NodeJS package manager

• You have created a secret named api_key to use in a workflow that deploys a new application. Which of the following is the correct syntax to reference the secret as an environment variable? steps: - shell: bash env: ENV_API_KEY: ${{ secrets.api_key }} run: | ./app_install.sh The correct syntax to reference a secret as an environment variable in a GitHub Actions workflow is to use the\({{ secrets.secret_name }}syntax. In this case, the secret named api_key is referenced as\)}within theenvsection of the workflow step. This allows the secret value to be securely accessed and used as an environment variable during the workflow execution.

• John has configured his workflow to save artifacts created from the build job. Where can John access the artifacts from the GitHub user interface that were saved within the build job? from the Artifacts section within the Actions workflow run - The artifacts saved from the build job can be accessed from the Artifacts section within the Actions workflow run. This section provides a convenient way for users like John to view and download any artifacts generated during the workflow execution, making it easy to access and utilize the output of the build job.

• What is the primary purpose of dependent jobs in a workflow? to define sequential execution order within a workflow - Dependent jobs in a workflow are used to define the sequential execution order within the workflow. This means that one job will only start after the successful completion of the job it depends on, ensuring a specific order of execution.

• Your operations team plans to use GitHub-hosted runners for continuous integration tasks, but the security team insists on implementing an IP address allowlist to enhance security measures. Why might this approach be considered cumbersome for your operations team? having to update the allowlist for GitHub-hosted runner IP addresses on a weekly basis could be time-consuming and error-prone - Updating the IP address allowlist for GitHub-hosted runners on a weekly basis can be cumbersome for the operations team because it requires manual effort and is prone to errors. This repetitive task can consume valuable time and resources, leading to potential security vulnerabilities if not done accurately and promptly.

• For an action that was triggered on: pull request, where can you see the workflow run status? (select three) in a pull request before a merge, from the Actions tab of the repository e on the Checks tab of the pull request

• Your organization uses GitHub Actions in Enterprise Cloud and wants to ensure automation is reused and maintained when creating new workflows in the organization's repositories. What feature should be used? workflow templates - Workflow templates in GitHub Actions allow organizations to create standardized, reusable automation workflows that can be easily applied to multiple repositories. By using workflow templates, organizations can ensure consistency, reduce duplication of effort, and maintain automation standards across their projects.

• How can you access an environment variable corresponding to an input in a Docker container action? use the args keyword in the action metadata file to pass the input to the Docker container - Using the args keyword in the action metadata file allows you to pass the input value as an argument to the Docker container. This argument can then be accessed within the container as an environment variable, enabling you to retrieve the corresponding input value efficiently.

• What is the minimum time granularity available for scheduling GitHub Actions? five minutes - GitHub Actions allows for scheduling workflows with a minimum time granularity of five minutes. This means that workflows can be scheduled to run at specific times or intervals with a precision of five minutes, providing flexibility in automation and execution timing.

• You have a workflow configured to run on branch protection rule events in your GitHub repository. However, you want to limit the workflow execution to exclude the deletion of branch protection rules. Which configuration should you use in your workflow file? on: branch_protection_rule: types: [created, edited] - By specifying the event types as [created, edited], the workflow will only run when branch protection rules are created or edited, excluding the deletion of branch protection rules. This configuration ensures that the workflow execution is limited to the desired events.

• When might it be appropriate to use a combination of GitHub-hosted and self-hosted runners in a workflow? when dealing with resource-intensive tasks - Using a combination of GitHub-hosted and self-hosted runners can be beneficial when dealing with resource-intensive tasks. GitHub-hosted runners may have limitations in terms of resources, so adding self-hosted runners with higher capabilities can help handle tasks that require more processing power or memory.

• You encounter an issue while executing a GitHub Actions workflow and need to print a debug message to the log for troubleshooting. How can you accomplish this? echo "::debug::executing the setup script" - The correct way to print a debug message to the log in GitHub Actions is by using theecho "::debug::message"syntax. This will output the specified message as a debug message in the workflow log, allowing you to troubleshoot the issue effectively.

Portugues¶

Questão 1¶

• Um desenvolvedor percebe que uma ação específica em seu fluxo de trabalho está falhando consistentemente. Ao inspecionar o arquivo de configuração do fluxo de trabalho, ele descobre que a ação deve ser acionada sempre que uma solicitação de pull for rotulada como 'urgente'. No entanto, a ação falha ao ser acionada mesmo quando o rótulo é aplicado corretamente. Qual é o motivo mais provável para esse problema? O gatilho de evento no arquivo de fluxo de trabalho está configurado incorretamente.
• Um fluxo de trabalho do GitHub Actions falha consistentemente em uma etapa que utiliza uma ação JavaScript com uma mensagem de erro indicando um problema com a versão do nó. Qual é a maneira mais apropriada de abordar esse problema? Adicione uma etapa para atualizar a versão do nó no ambiente do executor antes de executar a ação JavaScript.
• Um fluxo de trabalho do GitHub Actions falha consistentemente em uma etapa que utiliza uma ação JavaScript com uma mensagem de erro indicando um problema com a versão do nó. Qual é a maneira mais apropriada de abordar esse problema? Adicione uma etapa para atualizar a versão do nó no ambiente do executor antes de executar a ação JavaScript.
• Um fluxo de trabalho do GitHub Actions falha durante uma etapa que executa uma ação JavaScript. Os logs indicam um problema com um pacote ausente. Qual é a ação mais apropriada para resolver esse problema? Modifique a ação JavaScript para incluir uma etapa para instalar o pacote ausente.
• Um fluxo de trabalho do GitHub Actions falha durante uma etapa que executa uma ação JavaScript. Os logs indicam um problema com um pacote ausente. Qual é a ação mais apropriada para resolver esse problema? Modifique a ação JavaScript para incluir uma etapa para instalar o pacote ausente.
• Uma execução de fluxo de trabalho falhou e você precisa diagnosticar o problema. Qual das seguintes opções é o primeiro passo que você deve tomar? Revise os logs da execução com falha na aba Actions do repositório GitHub.
• Como engenheiro de DevOps, você tem a tarefa de gerenciar componentes reutilizáveis para os fluxos de trabalho da sua organização. Qual abordagem você deve adotar? Armazene componentes reutilizáveis em um repositório centralizado, estabeleça convenções de nomenclatura claras e crie um plano de manutenção.
• Como administrador do GitHub Actions, qual das seguintes práticas deve ser incluída em suas políticas de uso organizacional para o GitHub Actions? Auditoria e revisão regulares de ações para garantir a conformidade com os padrões de segurança e políticas organizacionais. E Defina diretrizes claras para criar, usar e compartilhar o GitHub Actions dentro da organização E Estabeleça um processo para atualizações regulares e manutenção de ações compartilhadas para abordar vulnerabilidades e melhorar o desempenho.
• Como administrador de uma organização do GitHub, você quer disponibilizar um segredo para vários repositórios. Qual é a abordagem correta? Crie um segredo de nível de organização e selecione os repositórios que devem ter acesso a ele.
• Como líder de uma equipe de DevOps, você tem a tarefa de gerenciar componentes reutilizáveis para fluxos de trabalho. Qual abordagem você deve adotar? Criar um repositório dedicado para componentes reutilizáveis, estabelecer convenções de nomenclatura claras e documentar procedimentos de manutenção.
• Considere que você está gerenciando fluxos de trabalho em um repositório do GitHub. Quais das seguintes ações estão corretas no contexto do GitHub Actions? Variáveis de ambiente personalizadas podem ser definidas no nível do fluxo de trabalho, trabalho ou etapa para flexibilidade. E Use o segredo GITHUB_TOKEN para autenticar e executar ações com a API do GitHub dentro de um fluxo de trabalho. E Para visualizar um histórico de todas as execuções de fluxo de trabalho, vá para a guia Actions do repositório.
• Durante a execução de uma ação de contêiner Docker em um fluxo de trabalho do GitHub Actions, você recebe um erro relacionado a variáveis de ambiente não sendo passadas corretamente. Qual das seguintes etapas tem mais probabilidade de resolver o problema? Adicione as variáveis de ambiente ausentes à seção env do fluxo de trabalho.
• Para uma ação GitHub personalizada projetada para implantar aplicativos em várias plataformas de nuvem, qual é o método mais eficaz para gerenciar e configurar as configurações de implantação específicas da plataforma? Utilize um arquivo de configuração no repositório do usuário para definir as configurações específicas da plataforma, que a ação lê e aplica durante a implantação. E exija que os usuários armazenem as configurações específicas da plataforma como segredos criptografados em seu repositório GitHub e façam referência a elas na ação.
• Para uma ação personalizada do GitHub que requer atualizações e manutenção periódicas, qual é a melhor estratégia para informar os usuários sobre as próximas alterações ou descontinuações que podem afetar seus fluxos de trabalho? Use o código da ação para exibir mensagens de aviso nos logs do fluxo de trabalho quando recursos descontinuados forem usados., Atualize o arquivo README do repositório da ação com detalhes sobre as alterações e descontinuações.
• Para uma ação personalizada do GitHub que você está desenvolvendo, qual método é mais apropriado para depurar problemas que ocorrem durante a execução da ação em um fluxo de trabalho? Utilize instruções console.log no código da ação e revise a saída nos logs do fluxo de trabalho do GitHub Actions.
• Para uma ação do GitHub que requer atualizações frequentes devido a alterações em dependências externas, qual estratégia deve ser empregada para testar e validar a funcionalidade da ação antes de liberar atualizações para garantir o mínimo impacto nos usuários? Configure um conjunto de testes automatizados que execute testes em uma variedade de cenários sempre que alterações forem feitas, usando os próprios recursos de CI/CD do GitHub Actions.
• Como os contêineres de banco de dados e serviços são utilizados em um fluxo de trabalho do GitHub Actions? Definindo serviços no arquivo de fluxo de trabalho, permitindo que os trabalhos usem os contêineres como parte do ambiente de tempo de execução.
• Como os contêineres de banco de dados e serviços são utilizados em um fluxo de trabalho do GitHub Actions? Definindo serviços no arquivo de fluxo de trabalho, permitindo que os trabalhos usem os contêineres como parte do ambiente de tempo de execução.
• Como os trabalhos dependentes são implementados em um fluxo de trabalho do GitHub Actions? Usando a palavra-chave needs para especificar dependências de trabalho, garantindo que certos trabalhos sejam executados somente após suas dependências terem sido concluídas com sucesso.
• Como os trabalhos dependentes são implementados em um fluxo de trabalho do GitHub Actions? Usando a palavra-chave needs para especificar dependências de trabalho, garantindo que os trabalhos sejam executados na ordem correta.
• Como os segredos criptografados são acessados dentro do GitHub Actions e fluxos de trabalho? Usando o contexto de segredos no arquivo de fluxo de trabalho para referenciar os segredos.
• Como os segredos criptografados são acessados dentro do GitHub Actions e fluxos de trabalho? Usando o contexto de segredos no arquivo de fluxo de trabalho para referenciar os segredos.
• Como os segredos criptografados são acessados dentro dos fluxos de trabalho do GitHub Actions? Usando o contexto de segredos no arquivo de fluxo de trabalho para referenciar os segredos pelo nome.
• Como os segredos criptografados são acessados dentro dos fluxos de trabalho do GitHub Actions? Usando o contexto de segredos no arquivo de fluxo de trabalho para referenciar os segredos pelo nome.
• Como um script personalizado pode ser integrado a um fluxo de trabalho do GitHub Actions? Usando a palavra-chave run em uma etapa dentro de um trabalho para executar o script.
• Como um script pode ser incorporado em um fluxo de trabalho do GitHub Actions? Usando a palavra-chave run em uma etapa para executar comandos de shell ou scripts.
• Como um emblema de status de fluxo de trabalho pode ser adicionado ao arquivo README de um repositório? Use o código markdown fornecido na guia Ações do repositório para incorporar o emblema de status.
• Como o cache pode ser configurado para acelerar a execução do fluxo de trabalho no GitHub Actions? Use a ação de cache para armazenar e recuperar dependências, reduzindo o tempo de instalação em execuções subsequentes.
• Como o cache pode ser configurado para acelerar a execução do fluxo de trabalho no GitHub Actions? Use a ação de cache para armazenar e recuperar dependências, reduzindo o tempo de instalação em execuções subsequentes.
• Como os dados podem ser passados entre trabalhos em um fluxo de trabalho do GitHub Actions? Usando artefatos para compartilhar dados entre trabalhos em um fluxo de trabalho.
• Como os artefatos de fluxo de trabalho podem ser removidos do GitHub depois que não forem mais necessários? Os artefatos podem ser configurados para expirar automaticamente após um certo número de dias.
• Como os artefatos de fluxo de trabalho podem ser removidos do GitHub depois que não forem mais necessários? Os artefatos podem ser configurados para expirar automaticamente após um certo número de dias.
• Como você pode acessar segredos criptografados dentro de um fluxo de trabalho do GitHub Actions? Use o contexto de segredos para acessar os segredos dentro do seu arquivo de fluxo de trabalho.
• Como você pode chamar corretamente um fluxo de trabalho reutilizável no GitHub Actions? Especificando o caminho do arquivo do fluxo de trabalho na palavra-chave uses em um trabalho.
• Como você pode chamar corretamente um fluxo de trabalho reutilizável no GitHub Actions? Especificando o caminho do arquivo do fluxo de trabalho na palavra-chave uses em um trabalho.
• Como você pode baixar artefatos de fluxo de trabalho da interface de usuário do GitHub Actions? Navegue até a aba Actions, selecione a execução de fluxo de trabalho específica e baixe os artefatos da seção Artifacts na parte inferior da página.
• Como você pode habilitar o registro de depuração de etapas em um fluxo de trabalho do GitHub Actions? Definindo o segredo ACTIONS_STEP_DEBUG como true nas configurações do repositório.
• Como você pode identificar o tipo, as entradas e as saídas de uma ação do GitHub? Lendo o arquivo action.yml da ação, que define a interface da ação, incluindo seu tipo, entradas e saídas necessárias.
• Como você pode identificar o tipo, as entradas e as saídas de uma ação do GitHub? Lendo o arquivo action.yml da ação, que define a interface da ação, incluindo seu tipo, entradas e saídas necessárias.
• Como você pode identificar o evento que acionou um fluxo de trabalho do GitHub Actions? Verificando a variável de ambiente GITHUB_EVENT_NAME nos logs de execução do fluxo de trabalho.
• Como você pode identificar o evento que acionou um fluxo de trabalho do GitHub Actions? Verificando a variável de ambiente GITHUB_EVENT_NAME nos logs de execução do fluxo de trabalho.
• Como você pode acionar um fluxo de trabalho do GitHub Actions no Repositório B sempre que uma nova versão for publicada no Repositório A, supondo que ambos os repositórios estejam na mesma organização? Use o evento repository_dispatch no Repositório B e acione-o usando um webhook do Repositório A após o lançamento.
• Como você pode usar o fluxo de trabalho de modelo de uma organização em um repositório? Selecionando o modelo na guia Ações do repositório e, em seguida, personalizando-o conforme necessário.
• Como você garante que um fluxo de trabalho use uma versão específica de uma ação do GitHub? Referenciando a ação no arquivo de fluxo de trabalho com uma tag de versão ou commit SHA após o nome da ação (por exemplo, actions/checkout@v4).
• Como um modelo de distribuição apropriado para uma GitHub Action deve ser selecionado? Com base no público-alvo e no escopo de uso, escolhendo entre distribuição pública, privada ou de mercado.
• Como uma organização deve configurar políticas de uso para GitHub Actions para garantir conformidade e eficiência? Defina diretrizes claras sobre uso, segurança e manutenção e aplique-as por meio de verificações e balanços automatizados.
• Se você estiver navegando em um repositório do GitHub pela primeira vez, onde normalmente encontrará os arquivos de fluxo de trabalho do GitHub Actions? No diretório .github/workflows na raiz do repositório.
• Em um fluxo de trabalho do GitHub Actions que é acionado por solicitações de pull que afetam qualquer arquivo, como você pode configurar um trabalho para ser executado somente se um arquivo específico tiver sido modificado e um trabalho anterior tiver sido concluído com sucesso? Combine a condição if e o atributo jobs.<job_id>.if para verificar o sucesso de um trabalho anterior e use uma etapa de script com git diff para verificar se um arquivo específico foi modificado
• Em um fluxo de trabalho do GitHub Actions que é acionado por solicitações de pull que afetam qualquer arquivo, como você pode configurar um trabalho para ser executado somente se um arquivo específico tiver sido modificado e um trabalho anterior tiver sido concluído com sucesso? Combine a condição if e o atributo jobs.<job_id>.if para verificar o sucesso de um trabalho anterior e use uma etapa de script com git diff para verificar se um arquivo específico foi modificado
• Em um fluxo de trabalho do GitHub Actions, como você pode configurar um trabalho para reutilizar artefatos gerados por um trabalho anterior no mesmo fluxo de trabalho? Implemente a etapa uses: actions/download-artifact@v2 dentro do trabalho, especificando o nome do artefato produzido pelo trabalho anterior.
• Em um fluxo de trabalho do GitHub Actions, como você pode reduzir eficientemente a duplicação de código quando as mesmas etapas são usadas em vários trabalhos? Implemente uma ação personalizada e faça referência a ela em cada trabalho em que as etapas são necessárias.
• Em um fluxo de trabalho do GitHub Actions, como você pode compartilhar dados gerados em um trabalho com trabalhos subsequentes no mesmo fluxo de trabalho? Use as ações upload-artifact e download-artifact para passar dados entre trabalhos.,
• Em um fluxo de trabalho do GitHub Actions, como você deve lidar com códigos de saída de um script para garantir o comportamento correto do fluxo de trabalho? Use o condicional if no arquivo de fluxo de trabalho para verificar códigos de saída específicos e lidar com eles adequadamente.
• Em um fluxo de trabalho do GitHub Actions, como você deve gerenciar com segurança informações confidenciais, como chaves de API ou credenciais de banco de dados? Use o GitHub Secrets e referencie-os no arquivo de fluxo de trabalho usando a sintaxe ${{ secrets.SECRET_NAME }}.
• Em um ambiente empresarial, qual é a melhor prática para monitorar e analisar o uso e o desempenho do GitHub Actions em vários repositórios e equipes? Implementar um sistema de registro e monitoramento centralizado que agregue dados de todos os fluxos de trabalho do GitHub Actions
• Em um ambiente empresarial, como um fluxo de trabalho do GitHub Actions deve ser configurado para garantir que dados confidenciais, como credenciais de banco de dados de produção, sejam gerenciados com segurança e acessados apenas por fluxos de trabalho autorizados? Armazene dados confidenciais como segredos criptografados no GitHub e restrinja o acesso a esses segredos usando as regras de proteção de ambiente do GitHub.
• Em um ambiente empresarial, como um fluxo de trabalho do GitHub Actions deve ser configurado para garantir que dados confidenciais, como credenciais de banco de dados de produção, sejam gerenciados com segurança e acessados apenas por fluxos de trabalho autorizados? Armazene dados confidenciais como segredos criptografados no GitHub e restrinja o acesso a esses segredos usando as regras de proteção de ambiente do GitHub
• Ao criar uma ação GitHub personalizada para impor padrões de codificação em vários projetos dentro de uma organização, qual estratégia deve ser empregada para permitir personalizações específicas do projeto, mantendo um conjunto comum de padrões? Crie uma ação base com padrões comuns e permita que os projetos estendam ou substituam esses padrões por meio de um arquivo de configuração no repositório de cada projeto.
• Ao criar uma ação GitHub personalizada para impor padrões de codificação em vários projetos dentro de uma organização, qual estratégia deve ser empregada para permitir personalizações específicas do projeto, mantendo um conjunto comum de padrões? Criar uma ação base com padrões comuns e permitir que os projetos estendam ou substituam esses padrões por meio de um arquivo de configuração no repositório de cada projeto
• Ao desenvolver uma ação personalizada do GitHub que gera e publica relatórios, como a ação deve ser projetada para lidar com arquivos de relatório grandes para garantir desempenho e uso de recursos eficientes? Armazene os arquivos de relatório externamente e forneça links de download na saída da ação. Compacte os arquivos de relatório dentro da ação antes de publicar para minimizar o tamanho do arquivo.
• Ao desenvolver uma ação personalizada do GitHub para integrar com uma ferramenta de gerenciamento de projetos para criação automatizada de tarefas, como a ação deve ser projetada para personalizar atributos de tarefa com base em diferentes tipos de eventos em um repositório do GitHub? Permitir que os usuários definam mapeamentos entre eventos do GitHub e atributos de tarefa em um arquivo de configuração dentro de seu repositório.
• No GitHub Actions, como você pode configurar um fluxo de trabalho para disparar apenas em pull requests que são abertos ou reabertos e, adicionalmente, apenas quando alterações são feitas em arquivos em um diretório específico? Use o gatilho on: pull_request com um campo types especificando aberto e reaberto, combinado com um filtro paths incluindo o diretório específico.
• No GitHub Actions, como você pode configurar um fluxo de trabalho para disparar apenas em pull requests que são abertos ou reabertos e, adicionalmente, apenas quando alterações são feitas em arquivos em um diretório específico? Use o gatilho on: pull_request com um campo types especificando aberto e reaberto, combinado com um filtro paths incluindo o diretório específico.
• No GitHub Actions, como você pode gerar dinamicamente uma matriz para um trabalho para ser executado em várias configurações, usando dados de um arquivo JSON externo hospedado no mesmo repositório? Implemente uma ação personalizada que leia o arquivo JSON e emita a configuração da matriz, então use essa saída na configuração da matriz do trabalho.
• No GitHub Actions, como você pode depurar efetivamente um trabalho com falha dentro de um fluxo de trabalho? Insira comandos echo no arquivo de fluxo de trabalho para imprimir valores de variáveis e saídas de comando em vários estágios.
• No GitHub Actions, como você pode depurar efetivamente um trabalho com falha dentro de um fluxo de trabalho? Insira comandos echo no arquivo de fluxo de trabalho para imprimir valores de variáveis e saídas de comando em vários estágios.
• No GitHub Actions, como você pode garantir que um trabalho em um fluxo de trabalho seja executado apenas em um dia específico da semana, por exemplo, toda sexta-feira? Use a sintaxe on: schedule com uma expressão cron no arquivo de fluxo de trabalho, como on: schedule: - cron: '0 0 * * 5'.
• No GitHub Actions, como você pode garantir que um trabalho em um fluxo de trabalho seja executado apenas em um dia específico da semana, por exemplo, toda sexta-feira? Use a sintaxe on: schedule com uma expressão cron no arquivo de fluxo de trabalho, como on: schedule: - cron: '0 0 * * 5'.
• No GitHub Actions, como você pode garantir que um trabalho específico em um fluxo de trabalho seja executado somente após dois outros trabalhos terem sido concluídos com sucesso? Implemente a palavra-chave needs: [job1, job2] na definição do trabalho para estabelecer uma dependência em job1 e job2.
• No GitHub Actions, como você pode garantir que um trabalho específico em um fluxo de trabalho seja executado somente se alterações forem feitas em arquivos em um dos dois diretórios diferentes? Crie um trabalho preliminar para verificar se há alterações nos diretórios especificados e use sua saída na condição if dos trabalhos dependentes.
• No GitHub Actions, como você pode garantir que um trabalho específico em um fluxo de trabalho seja executado somente se alterações forem feitas em arquivos em um dos dois diretórios diferentes? Crie um trabalho preliminar para verificar se há alterações nos diretórios especificados e use sua saída na condição if dos trabalhos dependentes.
• No GitHub Actions, como você pode executar seletivamente trabalhos dentro de um fluxo de trabalho com base no tipo de evento que acionou o fluxo de trabalho? Empregue a condição if: github.event_name == 'event_type' no início de cada trabalho para especificar quando o trabalho deve ser executado com base no tipo de evento.
• No GitHub Actions, como você pode configurar um fluxo de trabalho para ser executado em eventos push e pullrequest, mas garantir que trabalhos específicos sejam executados apenas para eventos pullrequest? Configure o fluxo de trabalho com on: [push, pull_request] e use condicionais if: github.event_name == 'pull_request' em trabalhos específicos.
• No GitHub Actions, como você pode configurar um fluxo de trabalho para ser executado em eventos push e pullrequest, mas garantir que trabalhos específicos sejam executados apenas para eventos pullrequest? Configure o fluxo de trabalho com on: [push, pull_request] e use condicionais if: github.event_name == 'pull_request' em trabalhos específicos.
• No GitHub Actions, como você pode configurar um fluxo de trabalho para disparar em um momento específico somente se houver alterações em uma ramificação específica desde a última execução bem-sucedida do fluxo de trabalho? Configure o fluxo de trabalho com o gatilho on: schedule e uma expressão cron, então use uma etapa de script para verificar se há alterações na ramificação desde a última execução.
• No GitHub Actions, como você pode utilizar artefatos gerados em um fluxo de trabalho em um fluxo de trabalho subsequente separado dentro do mesmo repositório? Use o gatilho on: workflow_run no fluxo de trabalho subsequente e utilize a ação actions/download-artifact@v2 para buscar os artefatos
• No GitHub Actions, como você configura corretamente um fluxo de trabalho para executar um trabalho somente quando um trabalho anterior falhou? Use a palavra-chave needs com a condição if: failure(), como needs: job1 e if: failure() na definição do trabalho.
• No GitHub Actions, como você configura corretamente um fluxo de trabalho para executar um trabalho somente quando um trabalho anterior falhou? Use a palavra-chave needs com a condição if: failure(), como needs: job1 e if: failure() na definição do trabalho.
• No GitHub Actions, como você deve configurar corretamente um fluxo de trabalho para disparar apenas em pull requests direcionados ao branch principal? Use on: pull_request: branches: [main] para especificar que o fluxo de trabalho deve ser executado apenas para pull requests direcionados ao branch principal.
• No GitHub Actions, como você configuraria um fluxo de trabalho para cancelar automaticamente execuções anteriores do mesmo fluxo de trabalho no mesmo branch quando uma nova execução for acionada? Use a palavra-chave concurrency com um nome de grupo exclusivo que inclua o nome do branch para cancelar automaticamente execuções sobrepostas.
• No GitHub Actions, como você configuraria corretamente um fluxo de trabalho para armazenar em cache dependências para um aplicativo Node.js para melhorar os tempos de compilação? Inclua uma etapa com uses: actions/cache@v2 e configure o caminho para node_modules, junto com uma chave apropriada com base no arquivo package-lock.json.
• No GitHub Actions, qual é a melhor prática para gerenciar e compartilhar variáveis de ambiente comumente usadas em vários trabalhos dentro de um fluxo de trabalho? Use a palavra-chave env no nível do fluxo de trabalho para definir variáveis de ambiente comuns para todos os trabalhos.
• No GitHub Actions, qual é a melhor prática para gerenciar e compartilhar variáveis de ambiente comumente usadas em vários trabalhos dentro de um fluxo de trabalho? Use a palavra-chave env no nível do fluxo de trabalho para definir variáveis de ambiente comuns para todos os trabalhos.
• No GitHub Actions, qual é a abordagem correta para garantir que um fluxo de trabalho seja acionado por um evento push somente quando arquivos ou diretórios específicos forem alterados? Use a sintaxe on: push: paths: ['specific-path/*'] para acionar o fluxo de trabalho somente quando ocorrerem alterações em arquivos ou diretórios em 'specific-path'.
• No GitHub Actions, qual é o método correto para reutilizar fluxos de trabalho armazenados em um repositório público no repositório privado da sua organização? Referencie o fluxo de trabalho público usando a palavra-chave uses com a URL do repositório e o caminho para o arquivo de fluxo de trabalho.
• No GitHub Actions, qual é o método correto para reutilizar fluxos de trabalho armazenados em um repositório público no repositório privado da sua organização? Referencie o fluxo de trabalho público usando a palavra-chave uses com a URL do repositório e o caminho para o arquivo de fluxo de trabalho.
• No GitHub Actions, qual é a abordagem recomendada para gerenciar e usar segredos (como chaves de API ou senhas) em um fluxo de trabalho que precisa acessar um serviço externo? Use o recurso de segredos criptografados do GitHub para armazenar e acessar segredos no fluxo de trabalho.
• No GitHub Actions, você quer consumir um fluxo de trabalho de outro repositório e acioná-lo sempre que um novo problema for aberto em seu repositório. Como você pode fazer isso? Use o evento on: repository_dispatch no fluxo de trabalho do repositório de destino e despache um evento do seu repositório quando um novo problema for aberto.
• No contexto de fluxos de trabalho de consumo no GitHub Actions, como você pode disparar um fluxo de trabalho em um repositório como resultado de um evento em um repositório separado? Use o evento on: repository_dispatch no repositório de consumo e envie um evento de despacho de repositório do repositório de origem.
• No contexto de consumo de fluxos de trabalho no GitHub Actions, qual dos seguintes é um método correto para especificar uma dependência entre trabalhos? Use a palavra-chave needs no trabalho que depende da conclusão de outro trabalho.
• No contexto da criação de uma ação personalizada do GitHub, qual é a melhor abordagem para lidar com informações confidenciais, como chaves de API ou credenciais, exigidas pela ação? Aconselhe os usuários a armazenar informações confidenciais como segredos criptografados em seu repositório do GitHub e passá-las como variáveis de ambiente para a ação.
• No contexto do GitHub Actions, qual é o uso correto da palavra-chave environment em um arquivo de fluxo de trabalho? environment é utilizado para especificar o ambiente de implantação, como produção, preparação ou desenvolvimento, e pode impor regras adicionais, como aprovações manuais.
• No desenvolvimento de uma ação GitHub personalizada, como você deve manipular e relatar erros que ocorrem durante a execução da ação para garantir que os usuários da ação possam depurar problemas de forma eficaz? Implemente o tratamento de erros personalizado no código da ação que captura e registra mensagens de erro detalhadas, usando os comandos de registro do GitHub para maior visibilidade.
• No desenvolvimento de uma ação personalizada do GitHub, qual é a maneira mais eficaz de lidar com diferentes ambientes de tempo de execução (por exemplo, produção, preparação, desenvolvimento) dentro da lógica da ação? Inclua parâmetros específicos do ambiente como entradas no arquivo action.yml da ação, permitindo que os usuários especifiquem o ambiente durante a configuração do fluxo de trabalho. e Utilize os segredos do ambiente do GitHub e faça com que a ação ajuste dinamicamente seu comportamento com base nesses segredos.
• No desenvolvimento de uma ação personalizada do GitHub, qual é a maneira mais eficaz de lidar com diferentes ambientes de tempo de execução (por exemplo, produção, preparação, desenvolvimento) dentro da lógica da ação? Utilize os segredos do ambiente do GitHub e faça com que a ação ajuste dinamicamente seu comportamento com base nesses segredos. e Inclua parâmetros específicos do ambiente como entradas no arquivo action.yml da ação, permitindo que os usuários especifiquem o ambiente durante a configuração do fluxo de trabalho.
• No processo de criação de uma GitHub Action personalizada, qual é a abordagem recomendada para garantir que a ação seja compatível com os executores Linux e Windows? Desenvolva a ação usando JavaScript, que é multiplataforma e suportado pelo ambiente do executor GitHub Actions no Linux e no Windows.
• No processo de construção de uma ação GitHub personalizada que se integra a um sistema de rastreamento de bugs para criar automaticamente problemas com base em confirmações de código, qual abordagem deve ser adotada para categorizar e priorizar esses problemas de forma eficiente? Use palavras-chave em mensagens de confirmação para determinar a prioridade e a categoria dos problemas e configure a ação para analisar essas palavras-chave.
• No processo de construção de uma ação GitHub personalizada que se integra a um sistema de rastreamento de bugs para criar automaticamente problemas com base em confirmações de código, qual abordagem deve ser adotada para categorizar e priorizar esses problemas de forma eficiente? Use palavras-chave em mensagens de confirmação para determinar a prioridade e a categoria dos problemas e configure a ação para analisar essas palavras-chave.
• No processo de criação de uma GitHub Action personalizada, qual é a melhor prática para garantir que a ação permaneça sustentável e fácil de atualizar conforme o GitHub Actions evolui e novos recursos são lançados? Assine o changelog do GitHub e atualize a ação somente quando necessário para manter a compatibilidade com a plataforma GitHub Actions. e Crie a ação com componentes modulares, permitindo atualizações fáceis e integração de novos recursos sem grandes refatorações.
• Em qual cenário é apropriado usar o segredo GITHUB_TOKEN em um fluxo de trabalho do GitHub Actions? Quando o fluxo de trabalho precisa interagir com a API do GitHub para executar ações como confirmar código, criar lançamentos ou gerenciar problemas e solicitações de pull.
• É possível distribuir ações e fluxos de trabalho para vários repositórios dentro de uma empresa, armazenando-os em um repositório .github centralizado e referenciando-os conforme necessário. Sim
• O que define com precisão o escopo de segredos criptografados no GitHub Actions? Segredos criptografados podem ser definidos no nível do repositório ou da organização, com acesso limitado a fluxos de trabalho específicos.
• Quais são os indicadores de que uma GitHub Action é confiável? A ação é publicada por uma organização conhecida, tem um número significativo de estrelas e documentação completa.
• O que você pode entender lendo um arquivo de configuração de fluxo de trabalho do GitHub Actions? As etapas e ações específicas que o fluxo de trabalho executará, juntamente com os eventos que o acionam.
• O que você pode entender lendo um arquivo de configuração de fluxo de trabalho do GitHub Actions? As etapas e ações específicas que o fluxo de trabalho executará, juntamente com os eventos que o acionam.
• Qual impacto a configuração de listas de permissão de IP tem em executores hospedados no GitHub e auto-hospedados? Ele restringe o acesso do executor somente aos endereços IP especificados na lista de permissão, aumentando a segurança.
• Qual é a melhor prática para distribuir ações personalizadas no GitHub Actions? Certifique-se de que a ação esteja bem documentada, incluindo instruções claras sobre uso, entradas e saídas.
• Qual é a melhor prática para distribuir ações personalizadas no GitHub Actions? Certifique-se de que a ação esteja bem documentada, incluindo instruções claras sobre uso, entradas e saídas.
• Qual é a melhor prática para manter runners auto-hospedados no GitHub Actions? Atualize regularmente o software dos runners e monitore seu desempenho e logs
• Qual é a melhor prática para gerenciar segredos criptografados no nível do repositório no GitHub Actions? Use as configurações do repositório para adicionar segredos criptografados que são específicos do repositório.
• Qual é um aspecto crucial do monitoramento de runners auto-hospedados em um ambiente empresarial? Verificar regularmente o status e as métricas de desempenho dos runners para garantir que eles operem de forma otimizada.
• Qual é uma etapa crucial ao configurar um fluxo de trabalho para publicar uma imagem no GitHub Container Registry? Autenticar com o GitHub Container Registry e enviar a imagem usando comandos apropriados dentro de uma execução de fluxo de trabalho
• Qual é uma consideração importante ao criar uma estratégia de lançamento para uma GitHub Action? Implemente o versionamento para rastrear alterações, facilitar a compatibilidade com versões anteriores e gerenciar lançamentos de forma eficaz.
• Qual é uma consideração importante ao criar uma estratégia de lançamento para uma GitHub Action? Implemente o versionamento para rastrear alterações, facilitar a compatibilidade com versões anteriores e gerenciar lançamentos de forma eficaz.
• Qual é uma consideração importante ao selecionar os executores apropriados para dar suporte a cargas de trabalho específicas? Selecione os executores com base nos requisitos de carga de trabalho, como poder de processamento ou dependências de software específicas.
• Qual é a principal diferença entre os executores hospedados no GitHub e os auto-hospedados no GitHub Actions? Os executores hospedados no GitHub fornecem um ambiente predefinido, enquanto os auto-hospedados oferecem mais controle e opções de personalização.
• Qual é a principal diferença entre os executores hospedados no GitHub e os auto-hospedados no GitHub Actions? Os executores hospedados no GitHub fornecem um ambiente predefinido, enquanto os auto-hospedados oferecem mais controle e opções de personalização.
• Qual é uma etapa fundamental ao publicar no GitHub Packages usando um fluxo de trabalho do GitHub Actions? Configure o fluxo de trabalho para autenticar com o GitHub Packages e envie o pacote usando o comando apropriado.
• Qual é uma etapa necessária ao configurar um fluxo de trabalho do GitHub Actions para implantar uma versão em um provedor de nuvem? Configure o fluxo de trabalho para autenticar com o provedor de nuvem e usar as ferramentas de implantação do provedor ou CLI dentro das etapas do fluxo de trabalho.
• Qual é o método principal para diagnosticar uma execução de fluxo de trabalho com falha do GitHub Actions? Verificar o histórico de execução do fluxo de trabalho e os logs para identificar mensagens de erro e as etapas em que a falha ocorreu.
• Qual é um aspecto essencial da definição da sintaxe para jobs em um arquivo de fluxo de trabalho do GitHub Actions? Jobs devem ser definidos com recuo correto e encapsulados dentro da palavra-chave jobs.
• Qual é uma etapa essencial ao configurar runners auto-hospedados para uso empresarial? Configure as configurações de rede, incluindo proxies e listas de permissão de IP, para garantir uma operação segura e eficiente dentro do ambiente empresarial.
• Qual é uma etapa essencial ao publicar uma ação no GitHub Marketplace? Certifique-se de que o repositório da ação seja público e inclua um arquivo README com instruções detalhadas de uso.
• Qual é uma etapa essencial ao publicar uma ação no GitHub Marketplace? Certifique-se de que o repositório da ação seja público e inclua um arquivo README com instruções detalhadas de uso.
• O que é crucial para a sintaxe correta de jobs em um arquivo de fluxo de trabalho do GitHub Actions? Jobs devem ser definidos sob a chave jobs com recuo adequado para garantir que a estrutura seja interpretada corretamente.
• O que é crucial para a sintaxe correta de jobs em um arquivo de fluxo de trabalho do GitHub Actions? Jobs devem ser definidos sob a chave jobs com recuo adequado para garantir que a estrutura seja interpretada corretamente.
• O que é crucial incluir no arquivo action.yml ao definir uma nova ação do GitHub? O nome, a descrição, as entradas, as saídas e as etapas de execução da ação.
• O que é essencial para definir corretamente a sintaxe de jobs em um arquivo de fluxo de trabalho do GitHub Actions? Jobs devem ser definidos sob a chave jobs, com recuo e estrutura adequados para garantir análise e execução corretas.
• Qual é a melhor prática para atualizar runners auto-hospedados? Implementar um cronograma de atualização regular para garantir que os runners tenham os recursos e patches de segurança mais recentes.
• Qual é a sintaxe correta para definir variáveis de ambiente personalizadas em uma etapa de um fluxo de trabalho do GitHub Actions? steps: - name: Exemplo de etapa run: echo "Hello world" env: CUSTOM_VAR: "value"
• Qual é a sintaxe correta para definir variáveis de ambiente personalizadas em uma etapa de um fluxo de trabalho do GitHub Actions? steps:- name: Exemplo de etapa run: echo "Hello world" env:CUSTOM_VAR: "value"
• Qual é a diferença entre desabilitar e excluir um fluxo de trabalho no GitHub Actions? Desabilitar um fluxo de trabalho impede que ele seja acionado, mas mantém o arquivo do fluxo de trabalho no repositório, enquanto excluir um fluxo de trabalho remove o arquivo completamente.
• Qual é a diferença entre desabilitar e excluir um fluxo de trabalho no GitHub Actions? Desabilitar um fluxo de trabalho impede que ele seja acionado, mas mantém o arquivo do fluxo de trabalho no repositório, enquanto excluir um fluxo de trabalho remove o arquivo completamente.
• Qual é a abordagem mais eficaz para distribuir ações dentro de uma empresa? Criar um repositório compartilhado centralizado e utilizar os recursos de rede interna do GitHub para distribuição.
• Qual é o principal benefício de poder mover corredores auto-hospedados para dentro e entre grupos? Permite gerenciamento flexível de recursos e se adapta às necessidades de mudança de projetos ou estruturas organizacionais.
• Qual é o principal benefício de configurar o cache para dependências de fluxo de trabalho no GitHub Actions? Para acelerar a execução do fluxo de trabalho reutilizando dependências baixadas ou criadas anteriormente.
• Qual é o objetivo principal de usar CodeQL em um fluxo de trabalho do GitHub Actions? Para analisar automaticamente a base de código em busca de vulnerabilidades e problemas de qualidade de código como parte do processo de CI/CD.
• Qual é o propósito de adicionar um emblema de status de fluxo de trabalho a um repositório? Para fornecer uma representação visual do status do fluxo de trabalho (por exemplo, aprovado, reprovado) no README do repositório ou em outras páginas da web.
• Qual é o propósito de adicionar um emblema de status de fluxo de trabalho a um repositório? Para fornecer uma representação visual do status do fluxo de trabalho (por exemplo, aprovado, reprovado) no README do repositório ou em outras páginas da web.
• Qual é o propósito de usar palavras-chave condicionais em etapas dentro de um fluxo de trabalho do GitHub Actions? Para controlar a execução de etapas específicas com base no resultado de etapas anteriores ou no contexto da execução do fluxo de trabalho.
• Qual é o propósito de usar palavras-chave condicionais em etapas dentro de um fluxo de trabalho do GitHub Actions? Para controlar a execução de etapas específicas com base no resultado de etapas anteriores ou no contexto da execução do fluxo de trabalho
• Qual é o propósito de usar palavras-chave condicionais em etapas dentro de um fluxo de trabalho do GitHub Actions? Para executar etapas somente se certas condições forem atendidas, adicionando flexibilidade e controle ao fluxo de trabalho.
• Qual é a maneira recomendada de passar dados entre trabalhos em um fluxo de trabalho do GitHub Actions? Use artefatos para compartilhar dados entre trabalhos, garantindo que a saída de um trabalho esteja disponível para trabalhos subsequentes.
• Qual é a maneira recomendada de passar dados entre trabalhos em um fluxo de trabalho do GitHub Actions? Use artefatos para compartilhar dados entre trabalhos, garantindo que a saída de um trabalho esteja disponível para trabalhos subsequentes.
• Qual é o papel dos portões de aprovação nos fluxos de trabalho do GitHub Actions? Para introduzir etapas de aprovação manual no fluxo de trabalho, permitindo que as partes interessadas revisem e aprovem as alterações antes de prosseguir.
• Qual é o papel do CodeQL quando usado como uma etapa em um fluxo de trabalho do GitHub Actions? Para analisar automaticamente a base de código em busca de vulnerabilidades e problemas de qualidade de código.
• Qual é a função de implementar comandos de fluxo de trabalho como uma etapa de execução em um fluxo de trabalho do GitHub Actions? Para se comunicar com o executor, definindo variáveis de ambiente ou alterando o comportamento do fluxo de trabalho.
• O que deve ser considerado ao configurar runners auto-hospedados para uso empresarial? Configure a rede, os proxies e os rótulos adequadamente para aderir às políticas e infraestrutura empresariais.
• Ao avaliar a confiabilidade de uma GitHub Action, o que você deve procurar? A ação tem avaliações positivas, é mantida ativamente e o código-fonte está disponível publicamente para revisão.
• Ao criar uma ação personalizada do GitHub que se integra a uma API externa, como você deve lidar com potenciais limites de taxa de API para evitar interrupções nos fluxos de trabalho do usuário? Implemente a lógica na ação para detectar erros de limite de taxa e repita a solicitação automaticamente após um atraso sensato E forneça uma opção para os usuários inserirem suas próprias chaves de API, permitindo que eles gerenciem seus limites de taxa de forma independente.
• Ao criar uma ação personalizada do GitHub que se integra a uma API externa, como você deve lidar com potenciais limites de taxa de API para evitar interrupções nos fluxos de trabalho do usuário? Forneça uma opção para os usuários inserirem suas próprias chaves de API, permitindo que eles gerenciem seus limites de taxa de forma independente. E implemente lógica na ação para detectar erros de limite de taxa e tentar novamente a solicitação automaticamente após um atraso sensato.
• Ao criar uma ação personalizada do GitHub para ser usada em vários projetos dentro de uma organização, qual é a melhor prática para lidar com atualizações da ação para minimizar interrupções nesses projetos? Lançar novas versões da ação usando tags de versão e instruir os projetos a usar versões específicas em vez do último commit no branch principal.
• Ao criar uma ação personalizada do GitHub, qual é a melhor prática para gerenciar e versionar a ação para garantir estabilidade e facilidade de manutenção para os usuários? Crie lançamentos ou tags específicos para versões estáveis da ação e aconselhe os usuários a referenciá-los em seus fluxos de trabalho.
• Ao criar uma ação GitHub personalizada baseada em JavaScript, qual é a abordagem recomendada para gerenciar dependências de terceiros que a ação requer? Agrupe as dependências com uma ferramenta como o Webpack e envie o arquivo agrupado junto com seu código de ação para o repositório.
• Ao criar e manter fluxos de trabalho no GitHub Actions, qual das seguintes afirmações é precisa? Os fluxos de trabalho são definidos em arquivos YAML e devem ser colocados no diretório .github/workflows do repositório
• Ao criar e manter fluxos de trabalho no GitHub Actions, qual afirmação está correta em relação ao uso de jobs..strategy em um arquivo de fluxo de trabalho? Dentro de strategy, a palavra-chave matrix pode ser usada para executar testes em várias versões de uma linguagem ou sistema operacional.
• Ao configurar listas de permissão de IP para runners hospedados no GitHub e auto-hospedados, qual é o efeito principal? Ele restringe quais endereços IP podem interagir com seus runners, aumentando a segurança.
• Ao consumir fluxos de trabalho no GitHub Actions, como você pode garantir que um fluxo de trabalho seja acionado somente quando uma nova versão for publicada em outro repositório dentro da mesma organização? Configure um evento repository_dispatch no repositório de origem e acione-o manualmente quando uma nova versão for publicada.
• Ao criar uma ação personalizada do GitHub em um repositório público, qual é a melhor prática para garantir que o código da ação esteja de acordo com os padrões de codificação consistentes e as melhores práticas? Implemente um linter no fluxo de trabalho de desenvolvimento da ação para verificar automaticamente os envios de código quanto à adesão aos padrões de codificação definidos.
• Ao criar uma ação personalizada do GitHub em um repositório público, qual é a melhor prática para garantir que o código da ação esteja de acordo com os padrões de codificação consistentes e as melhores práticas? Implemente um linter no fluxo de trabalho de desenvolvimento da ação para verificar automaticamente os envios de código quanto à adesão aos padrões de codificação definidos.
• Ao criar uma ação personalizada do GitHub que se integra a serviços de terceiros, qual abordagem deve ser adotada para lidar com interrupções ou tempo de inatividade do serviço para garantir o mínimo impacto na execução do fluxo de trabalho? Implemente a lógica de repetição na ação para tentar a reconexão ao serviço de terceiros um número definido de vezes antes de falhar., Forneça aos usuários a opção de pular etapas dependentes do serviço de terceiros durante interrupções, por meio de parâmetros de entrada na ação.
• Ao criar uma ação personalizada do GitHub que se integra a serviços de terceiros, qual abordagem deve ser adotada para lidar com interrupções ou tempo de inatividade do serviço para garantir o mínimo impacto na execução do fluxo de trabalho? Implemente a lógica de repetição na ação para tentar a reconexão ao serviço de terceiros um número definido de vezes antes de falhar. e Forneça aos usuários a opção de pular etapas dependentes do serviço de terceiros durante interrupções, por meio de parâmetros de entrada na ação.
• Ao criar uma ação personalizada do GitHub que deve evoluir e escalar ao longo do tempo, como o controle de versão e o gerenciamento de lançamento devem ser tratados para garantir compatibilidade com versões anteriores e minimizar a interrupção para os usuários? Implemente o versionamento semântico para a ação, usando tags para marcar versões de lançamento estáveis e instrua os usuários a referenciar versões específicas.
• Ao projetar uma ação personalizada do GitHub para atualizar automaticamente a documentação com base em alterações de código, qual é a melhor abordagem para garantir que a documentação permaneça sincronizada com a base de código em diferentes ramificações? Dispare a ação em cada evento push em todas as ramificações, garantindo que as atualizações da documentação ocorram em paralelo com as alterações de código. E implemente lógica na ação para detectar alterações de código que afetam a documentação e atualizar as ramificações relevantes de acordo.
• Ao projetar uma ação personalizada do GitHub para facilitar as revisões de código atribuindo revisores automaticamente com base no tipo de alterações feitas, qual método deve ser usado para determinar os revisores mais apropriados para cada solicitação de pull? Use um arquivo de configuração no repositório que mapeie tipos específicos de alterações para revisores relevantes, permitindo atualizações e personalização fáceis.
• Ao desenvolver uma ação de etapas de execução composta no GitHub Actions, qual é a maneira recomendada de incluir scripts externos ou arquivos de código dos quais a ação depende? Inclua os scripts externos ou arquivos de código no mesmo repositório que a ação e referencie-os usando caminhos relativos nas entradas runs.steps.
• Ao desenvolver uma ação GitHub personalizada baseada em Docker, qual é o método recomendado para passar parâmetros de entrada do fluxo de trabalho para o contêiner Docker? Defina parâmetros de entrada no arquivo de metadados da ação (action.yml) e acesse-os como variáveis de ambiente dentro do contêiner Docker.
• Ao desenvolver uma ação personalizada do GitHub para automatizar atualizações de dependências em um ambiente de projeto multilíngue, qual é a abordagem mais eficiente para lidar com atualizações em diferentes linguagens de programação e gerenciadores de pacotes? Implemente uma ação modular com plug-ins ou scripts para cada linguagem e gerenciador de pacotes, permitindo que a ação seja estendida conforme necessário.
• Ao desenvolver uma ação personalizada do GitHub para análise de código e linting, como você pode garantir melhor que a ação permaneça atualizada com os padrões e práticas de codificação mais recentes em um ecossistema de linguagem de programação em rápida evolução? Permitir que os usuários especifiquem seu próprio conjunto de regras ou vinculem a um conjunto de regras externo em sua configuração de fluxo de trabalho. E Integre a ação com uma ferramenta ou biblioteca de linting popular e ativamente mantida, atualizando automaticamente para a versão mais recente em cada execução.
• Ao desenvolver uma ação personalizada do GitHub para análise de código e linting, como você pode garantir melhor que a ação permaneça atualizada com os padrões e práticas de codificação mais recentes em um ecossistema de linguagem de programação em rápida evolução? Integre a ação com uma ferramenta ou biblioteca de linting popular e ativamente mantida, atualizando automaticamente para a versão mais recente em cada execução. E permita que os usuários especifiquem seu próprio conjunto de regras ou vinculem a um conjunto de regras externo em sua configuração de fluxo de trabalho.
• Ao desenvolver uma ação personalizada do GitHub que interage com APIs externas, qual é a melhor estratégia para gerenciar e rotacionar chaves ou tokens de API para aumentar a segurança? Armazene as chaves ou tokens de API como segredos criptografados no repositório do GitHub e faça referência a eles no código da ação.
• Ao desenvolver uma ação GitHub personalizada que envolva tarefas computacionais complexas, qual é a melhor abordagem para otimizar o desempenho e reduzir o tempo de execução? Implemente mecanismos de cache na ação para armazenar e reutilizar resultados computacionais sempre que possível. E descarregue as tarefas computacionais para um servidor externo ou serviço de nuvem e faça com que a ação interaja com esse serviço.
• Ao desenvolver uma ação personalizada do GitHub que envolve tarefas computacionais complexas, qual é a melhor abordagem para otimizar o desempenho e reduzir o tempo de execução? Descarregue as tarefas computacionais para um servidor externo ou serviço de nuvem e faça a ação interagir com esse serviço. e Implemente mecanismos de cache na ação para armazenar e reutilizar resultados computacionais sempre que possível.
• Ao diagnosticar uma execução de fluxo de trabalho do GitHub Actions com falha, quais das seguintes etapas são apropriadas? Revise o histórico de execução do fluxo de trabalho para identificar padrões ou problemas recorrentes. E use a API REST do GitHub para buscar programaticamente os logs da execução do fluxo de trabalho com falha.
• Ao implementar um fluxo de trabalho do GitHub Actions, como você pode pular condicionalmente um trabalho, a menos que um gatilho manual seja ativado, como um comentário em uma solicitação de pull? Use o gatilho on: issue_comment combinado com uma condição if de nível de trabalho verificando o conteúdo do comentário.
• Ao implementar um fluxo de trabalho do GitHub Actions, como você pode pular condicionalmente um trabalho, a menos que um gatilho manual seja ativado, como um comentário em uma solicitação de pull? Use o gatilho on: issue_comment combinado com uma condição if de nível de trabalho verificando o conteúdo do comentário.
• Ao implementar comandos de fluxo de trabalho dentro de uma ação para se comunicar com o executor, o que é importante considerar? Sempre use códigos de saída para comunicar o status da ação ao executor.
• Ao gerenciar e publicar GitHub Actions, quais das seguintes práticas são recomendadas? Forneça documentação abrangente, incluindo instruções de uso, descrições de entrada e saída e fluxos de trabalho de exemplo. E atualize e mantenha regularmente suas ações, garantindo que sejam compatíveis com os recursos e padrões de segurança mais recentes do GitHub. E use convenções de nomenclatura claras e descritivas para suas ações e repositórios.
• Ao gerenciar e publicar GitHub Actions, quais das seguintes práticas são recomendadas? Atualize e mantenha regularmente suas ações, garantindo que sejam compatíveis com os recursos e padrões de segurança mais recentes do GitHub. e Use convenções de nomenclatura claras e descritivas para suas ações e repositórios. E Forneça documentação abrangente, incluindo instruções de uso, descrições de entrada e saída e fluxos de trabalho de exemplo.
• Ao gerenciar segredos criptografados em nível de repositório, qual é uma prática importante? Os segredos devem ter escopo para ambientes ou ramificações específicas, limitando o acesso quando necessário.
• Ao gerenciar segredos criptografados em nível de repositório, qual é uma prática importante? Os segredos devem ter escopo para ambientes ou ramificações específicas, limitando o acesso quando necessário.
• Ao gerenciar executores para uma empresa, qual das seguintes práticas deve ser implementada? Selecione executores com base nos requisitos específicos de carga de trabalho, incluindo o sistema operacional necessário e as necessidades de hardware. E monitore, solucione problemas e atualize regularmente os executores auto-hospedados para garantir que estejam seguros e funcionando de forma ideal. E configure listas de permissão de IP para controlar o acesso aos executores auto-hospedados e hospedados no GitHub.
• Ao configurar um pipeline de CI/CD, como você deve selecionar os executores apropriados para dar suporte às suas cargas de trabalho? Escolha os executores com base nos requisitos da carga de trabalho, como o sistema operacional necessário ou necessidades específicas de hardware.
• Ao configurar um fluxo de trabalho do GitHub Actions, como você pode garantir que um trabalho seja executado somente se um trabalho anterior no fluxo de trabalho tiver falhado? Use a condição if: failure() combinada com a palavra-chave needs, como needs: [previous_job] e if: failure() na definição do trabalho.
• Ao configurar um fluxo de trabalho do GitHub Actions, como você pode garantir que um trabalho seja executado somente se um trabalho anterior no fluxo de trabalho tiver falhado? Use a condição if: failure() combinada com a palavra-chave needs, como needs: [previous_job] e if: failure() na definição do trabalho.
• Ao solucionar problemas de uma ação de contêiner Docker em um fluxo de trabalho do GitHub Actions, você percebe que a ação falha ao iniciar. Qual das seguintes etapas você deve executar primeiro? Verifique o Dockerfile para quaisquer erros de sintaxe ou dependências ausentes.
• Ao trabalhar com segredos criptografados no GitHub Actions, o que determina o escopo de um segredo criptografado? Se o segredo é armazenado no nível da organização ou no nível do repositório.
• Onde variáveis de ambiente personalizadas podem ser definidas em um fluxo de trabalho do GitHub Actions? Na chave env no nível do fluxo de trabalho, trabalho ou etapa.
• Onde você pode acessar os logs de uma execução de fluxo de trabalho do GitHub Actions na interface do usuário do GitHub? Na aba 'Ações' do repositório, selecionando a execução de fluxo de trabalho específica.
• Onde você pode localizar um arquivo de fluxo de trabalho em um repositório do GitHub? No diretório .github/workflows na raiz do repositório.
• Onde informações confidenciais, como tokens de acesso e senhas, devem ser armazenadas ao configurar fluxos de trabalho do GitHub Actions? Como segredos criptografados, que podem ser acessados no fluxo de trabalho por meio do contexto de segredos.
• Qual aspecto tem menos probabilidade de contribuir para a confiabilidade de uma ação listada no GitHub Marketplace? A ação é publicada por um indivíduo sem contribuições anteriores ao código aberto.
• Qual configuração permite que um fluxo de trabalho seja acionado por vários eventos no GitHub Actions? Use a palavra-chave on para especificar uma lista de eventos, como push, pull_request e schedule.
• Qual configuração permite que um fluxo de trabalho seja acionado por vários eventos no GitHub Actions? Use a palavra-chave on para especificar uma lista de eventos, como push, pull_request e schedule
• Qual configuração de evento aciona corretamente um fluxo de trabalho no GitHub Actions? Usando a palavra-chave on no arquivo de fluxo de trabalho para especificar o tipo de evento, como push, pull_request ou schedule.
• Qual configuração de evento aciona corretamente um fluxo de trabalho no GitHub Actions? Usando a palavra-chave on no arquivo de fluxo de trabalho para especificar o tipo de evento, como push, pull_request ou schedule.
• Qual método pode ser usado para acessar os logs de uma execução de fluxo de trabalho do GitHub Actions usando a API REST do GitHub? Envie uma solicitação GET para o endpoint apropriado com o ID de execução do fluxo de trabalho para recuperar os logs.
• Qual método pode ser usado para acessar os logs de uma execução de fluxo de trabalho do GitHub Actions usando a API REST do GitHub? Envie uma solicitação GET para o endpoint apropriado com o ID de execução do fluxo de trabalho para recuperar os logs.
• Quais das seguintes são configurações avançadas nos fluxos de trabalho do GitHub Actions? Adicionar proteções de ambiente para garantir que os fluxos de trabalho sejam executados apenas em contextos seguros e aprovados., Definir uma matriz de diferentes configurações de trabalho para testar em vários ambientes. e Remover artefatos de fluxo de trabalho após um determinado período para gerenciar o armazenamento e manter a limpeza.
• Quais das seguintes são configurações avançadas em fluxos de trabalho do GitHub Actions? Remover artefatos de fluxo de trabalho após um certo período para gerenciar o armazenamento e manter a limpeza. E Adicionar proteções de ambiente para garantir que os fluxos de trabalho sejam executados apenas em contextos seguros e aprovados E Definir uma matriz de diferentes configurações de trabalho para testar em vários ambientes.
• Quais das seguintes opções são benefícios de reutilizar modelos para ações e fluxos de trabalho no GitHub Actions? (Escolha 2) Reduz significativamente o tempo necessário para integrar novos membros da equipe. Garante consistência e melhores práticas em vários projetos.
• Quais das seguintes são práticas recomendadas para gerenciar segredos criptografados no GitHub Actions? Roteie segredos regularmente para minimizar o risco de exposição., Use segredos específicos do ambiente para personalizar o acesso com base nos estágios de implantação. e Audite o acesso aos segredos e revise o uso em fluxos de trabalho regularmente.
• Quais das seguintes são práticas recomendadas para gerenciar segredos criptografados no GitHub Actions? Use segredos específicos do ambiente para personalizar o acesso com base nos estágios de implantação., Audite o acesso aos segredos e revise o uso em fluxos de trabalho regularmente., Gire os segredos regularmente para minimizar o risco de exposição.
• Quais dos seguintes são componentes de um fluxo de trabalho do GitHub Actions? Palavras-chave condicionais que controlam a execução de trabalhos e etapas com base em certas condições. AND Jobs, que agrupam etapas individuais que são executadas como parte do fluxo de trabalho. AND Steps, que representam tarefas individuais, como executar um script ou uma ação.
• Quais das seguintes opções são etapas de solução de problemas eficazes para executores auto-hospedados? (Escolha 2) Verificar a conectividade de rede e os controles de acesso., Revisar logs em busca de mensagens de erro ou avisos.
• Quais das seguintes opções são verdadeiras em relação aos componentes e integração de ações, fluxos de trabalho, trabalhos, etapas, execuções e o marketplace no GitHub Actions? O Marketplace é uma plataforma onde ações pré-criadas podem ser publicadas e usadas dentro de fluxos de trabalho sem codificação personalizada., Palavras-chave condicionais podem ser usadas em etapas para controlar sua execução com base em certas condições. e Os fluxos de trabalho são processos automatizados definidos por trabalhos, que por sua vez consistem em etapas que podem incluir ações ou comandos de shell.
• Quais das seguintes opções são verdadeiras em relação aos componentes e integração de ações, fluxos de trabalho, trabalhos, etapas, execuções e o marketplace no GitHub Actions? Os fluxos de trabalho são processos automatizados definidos por trabalhos, que por sua vez consistem em etapas que podem incluir ações ou comandos de shell. O Marketplace é uma plataforma onde ações pré-construídas podem ser publicadas e usadas dentro de fluxos de trabalho sem codificação personalizada. e Palavras-chave condicionais podem ser usadas em etapas para controlar sua execução com base em certas condições.
• Quais das seguintes opções são etapas válidas para solucionar problemas de uma ação JavaScript em um fluxo de trabalho do GitHub Actions? Examine a documentação da ação para quaisquer problemas ou requisitos conhecidos. E Verifique o arquivo package.json para garantir que todas as dependências estejam listadas corretamente e as versões sejam compatíveis. E Revise os logs do fluxo de trabalho para quaisquer mensagens de erro ou indicações de onde o processo está falhando.
• Qual das seguintes é uma prática recomendada para gerenciar e alavancar componentes reutilizáveis em um ambiente empresarial? Utilize um repositório dedicado para armazenamento e estabeleça convenções de nomenclatura claras para arquivos e pastas.
• Quais das seguintes afirmações estão corretas em relação ao uso de variáveis de ambiente em fluxos de trabalho do GitHub Actions? Variáveis de ambiente padrão fornecem contexto predefinido sobre a execução do fluxo de trabalho, como o nome da ramificação ou o SHA de confirmação., Variáveis de ambiente personalizadas podem ser definidas no nível do fluxo de trabalho, trabalho ou etapa usando a palavra-chave env. e O comando de fluxo de trabalho GITHUB_ENV pode ser usado para definir variáveis de ambiente para etapas subsequentes em um trabalho.
• Quais das seguintes afirmações estão corretas em relação ao uso de variáveis de ambiente em fluxos de trabalho do GitHub Actions? O comando de fluxo de trabalho GITHUB_ENV pode ser usado para definir variáveis de ambiente para etapas subsequentes em um trabalho. E as variáveis de ambiente padrão fornecem contexto predefinido sobre a execução do fluxo de trabalho, como o nome da ramificação ou o SHA de confirmação E as variáveis de ambiente personalizadas podem ser definidas no nível do fluxo de trabalho, trabalho ou etapa usando a palavra-chave env.
• Qual opção configura corretamente um fluxo de trabalho do GitHub Actions para ser executado para vários eventos? Use a palavra-chave on no arquivo de fluxo de trabalho para listar vários eventos, como push, pull_request e schedule.
• Qual afirmação descreve com precisão a diferença entre runners hospedados no GitHub e auto-hospedados? Os runners hospedados no GitHub são totalmente gerenciados pelo GitHub, oferecendo conveniência, mas menos controle sobre o ambiente.
• Qual afirmação descreve com precisão a diferença entre runners hospedados no GitHub e auto-hospedados? Os runners hospedados no GitHub são totalmente gerenciados pelo GitHub, oferecendo conveniência, mas menos controle sobre o ambiente.
• Você é um administrador da sua organização GitHub e precisa disponibilizar um segredo para vários repositórios. Como você gerencia esse segredo? Armazene o segredo no nível da organização e conceda acesso aos repositórios necessários.
• Você está criando uma nova GitHub Action. Qual é a estrutura de arquivo e diretório necessária que você deve configurar? Um diretório na raiz do repositório contendo um Dockerfile ou um arquivo JavaScript e um arquivo action.yml.
• Você está criando uma nova GitHub Action. Qual é a estrutura de arquivo e diretório necessária que você deve configurar? Um diretório na raiz do repositório contendo um Dockerfile ou um arquivo JavaScript e um arquivo action.yml.
• Você está criando um fluxo de trabalho e quer incluir o nome do branch que disparou a execução do fluxo de trabalho no trabalho. Qual variável de ambiente padrão você deve usar? GITHUBREFNAME
• Você está elaborando políticas de uso organizacional para GitHub Actions. Qual dos seguintes deve ser incluído em suas políticas? Implemente mecanismos de monitoramento e auditoria para rastrear o uso e o desempenho de ações. , Defina diretrizes claras sobre a criação, compartilhamento e uso de GitHub Actions dentro da organização. e Revise e atualize regularmente as ações para garantir a conformidade com os padrões de segurança e as melhores práticas.
• Você está integrando uma nova ação ao seu fluxo de trabalho. Como você pode identificar o tipo da ação, as entradas necessárias e as saídas esperadas? Lendo o arquivo README.md da ação e o arquivo de metadados da ação (action.yml ou action.yaml).
• Você está integrando uma nova ação ao seu fluxo de trabalho. Como você pode identificar o tipo da ação, entradas necessárias e saídas esperadas?Lendo o arquivo README.md da ação e o arquivo de metadados da ação (action.yml ou action.yaml).
• Você está gerenciando um conjunto de runners auto-hospedados para sua empresa no GitHub Actions. Como você pode gerenciar o acesso e organizar esses runners de forma eficaz? Crie grupos para runners e atribua runners a grupos com base no uso ou nas necessidades do departamento.
• Você está gerenciando fluxos de trabalho do GitHub Actions nos repositórios da sua organização. Quais das seguintes práticas você deve seguir? Use segredos criptografados para armazenar e acessar informações confidenciais, como chaves de API e senhas em fluxos de trabalho., Revise e integre atualizações para ações com cautela, garantindo que elas não quebrem fluxos de trabalho existentes. e Revise e atualize regularmente as ações usadas em seus fluxos de trabalho para garantir que elas recebam atualizações e melhorias de segurança.
• Você está gerenciando fluxos de trabalho do GitHub Actions nos repositórios da sua organização. Quais das seguintes práticas você deve seguir? Use segredos criptografados para armazenar e acessar informações confidenciais, como chaves de API e senhas em fluxos de trabalho.
• Você está gerenciando segredos para um repositório específico em sua organização. O que você deve considerar ao criar segredos criptografados em nível de repositório? Segredos em nível de repositório são melhores para dados sensíveis específicos de um repositório e não são acessíveis por outros repositórios.
• Você está gerenciando segredos para um repositório específico em sua organização. O que você deve considerar ao criar segredos criptografados em nível de repositório? Segredos em nível de repositório são melhores para dados sensíveis específicos de um repositório e não são acessíveis por outros repositórios.
• Você está planejando lançar uma série de atualizações para sua GitHub Action. Qual abordagem você deve adotar para criar uma estratégia de lançamento eficaz? Use versionamento semântico para marcar lançamentos, fornecendo informações claras sobre a natureza de cada update.nnels.
• Você é responsável por garantir que o GitHub Actions seja usado de forma segura e apropriada dentro da sua empresa. Como você pode controlar o acesso a essas ações? Implemente controles de acesso baseados em função no nível da organização e integre com o sistema de gerenciamento de identidade da empresa.
• Você é responsável por garantir que as GitHub Actions sejam usadas de forma segura e apropriada dentro da sua empresa. Como você pode controlar o acesso a essas ações? Implemente controles de acesso baseados em função no nível da organização e integre com o sistema de gerenciamento de identidade da empresa.
• Você está revisando um fluxo de trabalho do GitHub Actions e encontra uma ação definida no arquivo de fluxo de trabalho. Como você pode identificar o tipo de ação usada (por exemplo, JavaScript, contêiner Docker ou composto)? Verificando a seção runs no arquivo action.yml ou action.yaml da ação.
• Você está configurando um pipeline de CI/CD para um projeto que requer um sistema operacional específico. Como você deve selecionar um executor apropriado? Escolha um executor hospedado no GitHub que suporte o sistema operacional necessário.
• Você está configurando segredos criptografados para seus projetos. Como o escopo de segredos criptografados difere entre o nível da organização e o nível do repositório no GitHub Actions? Segredos no nível da organização podem ser disponibilizados para vários repositórios, enquanto segredos no nível do repositório são acessíveis apenas ao repositório em que estão definidos.
• Você está configurando segredos criptografados para seus projetos. Como o escopo de segredos criptografados difere entre o nível da organização e o nível do repositório no GitHub Actions? Segredos no nível da organização podem ser disponibilizados para vários repositórios, enquanto segredos no nível do repositório são acessíveis apenas ao repositório em que estão definidos.
• Você tem a tarefa de criar uma nova ação GitHub personalizada para o fluxo de trabalho da sua organização. Quais metadados e sintaxe são essenciais para definir no arquivo de configuração da ação para que ela funcione corretamente? Um arquivo action.yml ou action.yaml contendo os metadados e as seções inputs, outputs e runs.
• Você tem dois repositórios do GitHub: Repositório A e Repositório B. Você quer configurar um fluxo de trabalho no Repositório A para disparar automaticamente sempre que uma nova solicitação de pull for criada no Repositório B. Qual é a melhor maneira de configurar essa integração? Configure um webhook no Repositório B para disparar um evento repository_dispatch no Repositório A sempre que uma solicitação de pull for criada.
• Você precisa recuperar programaticamente os logs de uma execução específica do fluxo de trabalho do GitHub Actions. Como você pode fazer isso? Use a API REST do GitHub e envie uma solicitação GET para o endpoint apropriado com o ID de execução do fluxo de trabalho.
• Você precisa reorganizar seus runners auto-hospedados devido a mudanças nas alocações de projetos. Como você pode mover um runner de um grupo para outro? Use a interface de gerenciamento de runner do GitHub para reatribuir o runner a um grupo diferente.
• Você percebe que um fluxo de trabalho foi acionado e concluiu uma série de tarefas em seu repositório. Como você pode identificar o evento que acionou esse fluxo de trabalho? Examine a variável de ambiente GITHUB_EVENT_NAME nos logs de execução do fluxo de trabalho para ver o tipo de evento que acionou o fluxo de trabalho.
• Você quer garantir estabilidade em seus fluxos de trabalho usando uma versão específica de uma ação. Como você pode referenciar corretamente uma versão específica de uma ação em seu arquivo de fluxo de trabalho? Usando o nome da ação seguido pelo símbolo @ e a tag de versão ou commit SHA (por exemplo, actions/checkout@v2).
• Você quer garantir estabilidade em seus fluxos de trabalho usando uma versão específica de uma ação. Como você pode referenciar corretamente uma versão específica de uma ação em seu arquivo de fluxo de trabalho? Usando o nome da ação seguido pelo símbolo @ e a tag de versão ou commit SHA (por exemplo, actions/checkout@v2). E
• Você quer garantir que GitHub Actions específicas sejam usadas somente por pessoal autorizado dentro da sua organização. Qual é uma maneira eficaz de conseguir isso? Implemente controles de acesso baseados em função e integre com o sistema de gerenciamento de identidade da organização.
• Você quer garantir que GitHub Actions específicas sejam usadas somente por pessoal autorizado dentro da sua organização. Qual é uma maneira eficaz de conseguir isso? Implemente controles de acesso baseados em função e integre com o sistema de gerenciamento de identidade da organização.
• Você está mantendo um repositório e decide que um fluxo de trabalho específico não é necessário pelos próximos dois meses, mas pode ser útil mais tarde. Que ação você tomaria? Desabilite o fluxo de trabalho para impedir temporariamente que ele seja acionado
• Você desenvolveu uma GitHub Action personalizada para automatizar implantações. Sua ação provavelmente será benéfica para outros projetos fora da sua organização. Como você deve distribuir sua ação? Publique a ação no GitHub Marketplace para torná-la publicamente disponível.
• Você desenvolveu uma GitHub Action personalizada para automatizar implantações. Sua ação provavelmente será benéfica para outros projetos fora da sua organização. Como você deve distribuir sua ação? Publique a ação no GitHub Marketplace para torná-la publicamente disponível.
• Você finalizou uma nova GitHub Action que automatiza verificações de qualidade de código. Como você pode publicar essa ação no GitHub Marketplace? Crie um repositório público para a ação, libere-o usando tags e, em seguida, publique-o por meio da seção marketplace nas configurações do seu repositório.
• Você acabou de corrigir um bug em seu aplicativo e o fluxo de trabalho de CI foi executado com sucesso, gerando relatórios de teste como artefatos. Como você baixaria esses artefatos da interface do usuário do GitHub? Navegue até a aba Actions, selecione a execução específica do fluxo de trabalho e encontre a seção Artifacts para baixar os relatórios.
• Sua empresa requer um método seguro e eficiente para distribuir GitHub Actions entre várias equipes. Qual é a melhor abordagem? Criar um repositório compartilhado centralizado para ações e aplicar controles de acesso.
• Sua empresa requer um método seguro e eficiente para distribuir GitHub Actions entre várias equipes. Qual é a melhor abordagem? Criar um repositório compartilhado centralizado para ações e aplicar controles de acesso.
• Sua empresa requer uma abordagem sistemática para distribuir GitHub Actions entre várias equipes. Qual é a estratégia mais eficaz? Desenvolva um repositório privado e centralizado para ações e gerencie o acesso usando o sistema de permissão integrado do GitHub.
• Sua organização tem um modelo de fluxo de trabalho padrão para CI/CD que você deseja usar em seu novo projeto. Como você aplica esse modelo ao repositório do seu projeto? Selecione o fluxo de trabalho com modelo na guia Actions do seu repositório e personalize-o, se necessário.
• Sua organização tem requisitos de segurança rigorosos. Qual seria o efeito de configurar listas de permissão de IP em runners hospedados no GitHub e auto-hospedados? Ele restringe o acesso à rede, permitindo que apenas o tráfego de endereços IP especificados interaja com os runners.
• Sua organização tem requisitos de segurança rigorosos. Qual seria o efeito de configurar listas de permissão de IP em runners hospedados no GitHub e auto-hospedados? Ele restringe o acesso à rede, permitindo que apenas o tráfego de endereços IP especificados interaja com os runners.
• Sua organização quer garantir que apenas equipes específicas tenham acesso a certos runners auto-hospedados. Como você pode gerenciar o acesso de forma eficaz? Use a interface de gerenciamento de runners do GitHub para definir permissões de acesso para cada grupo de runners.
• Sua organização quer garantir que apenas equipes específicas tenham acesso a certos runners auto-hospedados. Como você pode gerenciar o acesso de forma eficaz? Use a interface de gerenciamento de runners do GitHub para definir permissões de acesso para cada grupo de runners.
• Sua equipe frequentemente cria novos repositórios e quer padronizar o processo de CI/CD. Qual é a maneira mais eficaz de conseguir isso com o GitHub Actions? Utilize modelos de fluxo de trabalho armazenados em um repositório .github designado e faça referência a eles em novos repositórios.
• Sua equipe desenvolveu uma GitHub Action que contém lógica de negócios sensível específica para os processos internos da sua organização. Você quer garantir que essa ação não seja acessível fora da sua organização. Qual modelo de distribuição você deve selecionar para essa ação? Armazene a ação em um repositório privado dentro da sua organização e gerencie o acesso por meio de permissões de repositório.
• Sua equipe precisa executar uma série de comandos shell como parte do seu pipeline de CI/CD para configurar o ambiente antes de implantar seu aplicativo. Que tipo de ação você deve usar no seu fluxo de trabalho do GitHub Actions para realizar essa tarefa? Uma etapa de execução que executa diretamente os comandos shell no ambiente do executor.
• Sua equipe quer padronizar processos de CI/CD em vários projetos. Como os modelos de fluxo de trabalho e ação podem ser reutilizados de forma eficaz? Use um repositório .github centralizado para armazenar modelos de fluxo de trabalho e referenciá-los em repositórios de projetos individuais.
• Sua equipe quer padronizar processos de CI/CD em vários projetos. Como os modelos de fluxo de trabalho e ação podem ser reutilizados de forma eficaz? Use um repositório .github centralizado para armazenar modelos de fluxo de trabalho e referenciá-los em repositórios de projetos individuais.

flowchart LR
DS[(Data Source)] & newLines["`Data
    Sources`"] --> |Pull/Push| id1(Ferramentas</br>Ingestão)
    id1 --> id2(Processamento</br>de dados)
    id2 --> id3(Armazenamento</br>de dados)
    id3 --> id4(Consumo</br>de dados)