DEV Community: Pratik Kale

How to Manage Google Cloud Compute Engine with Python

Pratik Kale — Fri, 08 Sep 2023 09:47:46 +0000

Compute Engine is an IaaS offering by Google Cloud. It is a powerful platform that can be used to create and manage virtual machines. However, managing Compute Engine can be a complex task. In this blog post, I will show you how to use Python to automate the management of Compute Engine instances.

Setting up your environment

Make sure you have python and pip installed.

Installation

Mac/Linux

pip install virtualenv
virtualenv <your-env>
source <your-env>/bin/activate
<your-env>/bin/pip install google-cloud-compute

Windows

pip install virtualenv
virtualenv <your-env>
<your-env>\Scripts\activate
<your-env>\Scripts\pip.exe install google-cloud-compute

Authentication

For authentication let's create a service account.

IAM & Admin --> Service Accounts
Click on CREATE SERVICE ACCOUNT.

Add a Service account name and Service account ID.
Click on CREATE AND CONTINUE.
Add Role of Compute Admin.
Click on DONE.

Now let's generate a JSON key which we can use in our local environment.

Click on the service account name you just created.
Click on the KEYS option.
ADD KEY --> Create new key
Select JSON and click on CREATE.
Download and Save the key.

Now that we have authentications sorted let's look at some code!

Creating a new VM instance

from google.cloud import compute_v1
import os

# Using os we are storing the service account json key in the variable
os.environ["GOOGLE_APPLICATION_CREDENTIALS"]= "key.json"

INSTANCE_NAME = 'instance-name'
MACHINE_TYPE = 'projects/project-id/zones/us-west4-b/machineTypes/e2-medium' 
SUBNETWORK = 'projects/project-id/regions/us-west4/subnetworks/default'
SOURCE_IMAGE = 'projects/project-id/global/images/ubuntu-2004-focal-v20230831'
NETWORK_INTERFACE = {
    'subnetwork':SUBNETWORK,
    'access_configs': [
        {
            'name':'External NAT'
        }
    ]
}

compute_client = compute_v1.InstancesClient()

config = {
    'name' : INSTANCE_NAME,
    'machine_type' : MACHINE_TYPE,
    'disks': [
        {
            'boot': True,
            'auto_delete': True,
            'initialize_params': {
                'source_image': SOURCE_IMAGE,
            }
        }
    ],

    'network_interfaces' : [NETWORK_INTERFACE]
}

print("Creating instace.....")
operation = compute_client.insert(
    project='project-id',
    zone='us-west4-b',
    instance_resource=config
)

operation.result()

print(f'Created VM Instance:{INSTANCE_NAME}')

Imported Modules :

google.cloud.compute_v1: This module provides the client library for the Google Cloud Compute Engine API.
os: This module provides access to operating system functionality.

This is how the code works:

Sets the environment variable GOOGLE_APPLICATION_CREDENTIALS to the path of the JSON file that contains the Google Cloud service account credentials.
Defines the following variables:

* `INSTANCE_NAME`: The name of the instance to create.

* `MACHINE_TYPE`: The machine type of the instance to create.

* `SUBNETWORK`: The subnetwork of the instance to create.

* `SOURCE_IMAGE`: The image to use for the instance.

* `NETWORK_INTERFACE`: The network interface of the instance to create.

Creates an instance of the InstancesClient class. This class provides methods for managing Google Compute Engine instances.
Creates a dictionary called config. This dictionary contains the configuration for the instance to create.
Calls the insert() method of the InstancesClient class. This method creates the instance.
Waits for the operation to complete.
Prints the name of the instance that was created.

If you are not sure about arguments like MACHINE_TYPE or SOURCE_IMAGE then you can refer to the Google Cloud Console.

Compute Engine --> VM instances
Click on CREATE INSTANCE.
Choose the arguments according to you.

Once done click on the EQUIVALENT CODE option in the upper right corner and choose REST

Here you can see all the available arguments and you can choose as per your requirements.

List all the VM instances

from google.cloud import compute_v1
from collections import defaultdict
import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"]= "key.json"

instace_client = compute_v1.InstancesClient()
request = compute_v1.AggregatedListInstancesRequest()
request.project = 'project-id'

agg_list = instace_client.aggregated_list(request=request)

all_instances = defaultdict(list)
print("Instances found:")
for zone, response in agg_list:
        if response.instances:
            all_instances[zone].extend(response.instances)
            print(f" {zone}:")
            for instance in response.instances:
                print(f" - {instance.name} ({instance.machine_type}) {instance.status}")

Imported Modules :

collections.defaultdict: This module provides a defaultdict data structure, which is a dictionary where the default value is set to a specified value.

This is how the code works:

Sets the environment variable GOOGLE_APPLICATION_CREDENTIALS to the path of the JSON file that contains the Google Cloud service account credentials.
Creates an instance of the InstancesClient class. This class provides methods for managing Google Compute Engine instances.
Creates an instance of the AggregatedListInstancesRequest class. This class represents a request to list Google Compute Engine instances.
Sets the project ID of the project that contains the instances to list.
Calls the aggregated_list() method of the InstancesClient class. This method lists the instances in the specified project.
Creates a dictionary called all_instances. This dictionary will be used to store the instances that are found.
Iterates over the response from the aggregated_list() method.
For each zone in the response, adds the instances in that zone to the all_instances dictionary.
Prints the name, machine type, and status of each instance in the all_instances dictionary.

This how the output looks like. I have printed the instance name, machine type and status but you can print every attribute of the instance from the all_instances dictionary.

Start and stop a VM instance

from google.cloud import compute_v1
import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"]= "key.json"

compute_client = compute_v1.InstancesClient()

operation = compute_client.stop(
    project='project-id',
    zone='us-west4-b',
    instance='python-instance'
)

operation.result()
print("Instace Stopped!")

This is straightforward. All you have to provide is project-id, zone and instance name.

Creates an instance of the InstancesClient class. This class provides methods for managing Google Compute Engine instances.
Calls the stop() method of the InstancesClient class. This method stops the instance.

The same applies for starting an instance. Rather than stop you have to use the start method rest is the same.

from google.cloud import compute_v1
import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"]= "key.json"

compute_client = compute_v1.InstancesClient()

operation = compute_client.start(
    project='project-id',
    zone='us-west4-b',
    instance='python-instance'
)

operation.result()
print("Instace Started!")

Delete a VM Instance

from google.cloud import compute_v1
import os

os.environ["GOOGLE_APPLICATION_CREDENTIALS"]= "key.json"

compute_client = compute_v1.InstancesClient()

operation = compute_client.delete(
    project='project-id',
    zone='us-west4-b',
    instance='instance-name'
)

operation.result()
print("Instace deleted successfully!")

Deleting also has the same logic as starting or stopping.

Creates an instance of the InstancesClient class. This class provides methods for managing Google Compute Engine instances.
Calls the delete() method of the InstancesClient class. This method deletes the instance.

All the code mentioned in this blog is available on GitHub

pratikkalein / GCP-Python

Python code for operations on Google Cloud compute engine

That's all about how you can manage VM instances using python. Let me know your thoughts or if I missed something in the comments.

Thank you for reading!

Connect With Me :

pratik.linkb.org

Best Practices for Using Git and GitHub

Pratik Kale — Sun, 02 Jul 2023 19:36:49 +0000

Welcome to the eighteenth blog of the series!

Now that we have gone through how you can get started with Git & GitHub.However, it's important to follow best practices to ensure a smooth and efficient Git workflow. In this blog post, we will explore some of the best practices for using Git and GitHub, including branching strategies, commit conventions, code reviews, and more. Let's dive in!

1. Choose an Appropriate Branching Strategy

A well-defined branching strategy helps in organizing and managing your codebase. Here are two popular branching strategies:

a. GitFlow

GitFlow is a branching model that emphasizes the separation of development work and release processes. It consists of two main branches:

master: Represents the stable production-ready code.
develop: Serves as the integration branch for ongoing development.

Additionally, GitFlow incorporates feature branches for new features, hotfix branches for bug fixes, and release branches for version releases.

To create a new feature branch using GitFlow:

# Create a new feature branch
git checkout -b feature/my-feature develop

b. Trunk-Based Development

Trunk-Based Development promotes a simpler branching model with a single long-lived branch, often named main or master. Developers directly commit their changes to this branch, eliminating the need for long-lived feature branches.

To commit changes directly to the main branch:

# Make changes to your code
git add .
git commit -m "Your commit message"
git push origin main

Choose a branching strategy that suits your team's needs and ensure everyone understands and follows it consistently.

2. Write Clear and Descriptive Commit Messages

Commit messages are crucial for understanding the purpose and context of code changes. Follow these guidelines when writing commit messages:

Keep messages concise but descriptive.
Use the imperative mood ("Fix bug" instead of "Fixed bug").
Reference relevant issue or ticket numbers, if applicable.

For example:

Add authentication middleware

This commit adds a new middleware for handling user authentication.
It checks the validity of user tokens before processing requests.
Fixes #123

3. Perform Regular Pulls and Branch Updates

To ensure you are working with the latest code and avoid conflicts, regularly pull changes from the remote repository and update your branches.

# Switch to the branch you want to update
git checkout my-branch

# Fetch the latest changes
git fetch origin

# Merge the changes from the remote branch into your local branch
git merge origin/my-branch

4. Utilize Pull Requests and Code Reviews

Pull Requests (PRs) and code reviews are essential for maintaining code quality and ensuring collaboration. Here's a typical workflow:

Create a new branch for your feature or bug fix.
Make your changes, commit them, and push the branch to the remote repository.
Open a PR on GitHub.
Request reviews from your team members.
Address any feedback and make necessary changes.
Once approved, merge the PR into the main branch.

Code reviews provide an opportunity for knowledge sharing, catching bugs, and improving code readability.

5. Use Issue Tracking and Milestones

GitHub's issue tracking features allow you to effectively manage and track tasks, bugs, and feature requests. Utilize issues and milestones to:

Document and discuss specific tasks or bugs.
Assign issues to team members.
Track progress using milestones and labels.
Provide a centralized location for discussions and collaboration.

6. Regularly Update and Rebase Long-Lived Branches

Long-lived branches like develop or main can diverge from other branches over time. To keep them up-to-date and minimize conflicts, periodically rebase or merge changes from other branches.

# Update your branch with the latest changes from main
git checkout my-branch
git pull origin main

Conclusion

Following best practices when using Git and GitHub can significantly improve your development workflow, collaboration, and code quality. Choosing an appropriate branching strategy, writing clear commit messages, performing regular pulls and updates, leveraging pull requests and code reviews, utilizing issue tracking, and keeping long-lived branches up-to-date are all essential practices. By incorporating these practices into your development process, you can ensure a smooth and efficient Git and GitHub experience for yourself and your team. Happy coding!

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

Troubleshooting Common Git Issues

Pratik Kale — Sun, 02 Jul 2023 19:16:42 +0000

Welcome to the seventeenth blog of the series!

Git is a powerful version control system that helps developers track changes to their codebase efficiently. However, like any other tool, Git can sometimes throw errors or present unexpected behavior. In this blog post, we will explore some common Git issues that developers encounter and provide troubleshooting steps to resolve them. Whether you're a beginner or an experienced Git user, understanding how to troubleshoot these issues will help you maintain a smooth Git workflow.

1. Git Repository Not Found

If you encounter the error "fatal: repository not found" when trying to clone a repository or perform Git operations, it typically indicates an issue with the repository URL or permissions. Here's how to troubleshoot:

Double-check the repository URL: Ensure that you have the correct repository URL. Verify if the URL is spelled correctly and includes the correct username or organization name.
Check repository permissions: If you're trying to clone a private repository, make sure you have the necessary permissions to access it. If the repository is owned by an organization, ensure that you are a member with the appropriate access rights.

2. Merge Conflicts

Merge conflicts occur when Git cannot automatically merge changes from different branches. It happens when multiple developers make conflicting changes to the same file or lines of code. Here's how to resolve merge conflicts:

Identify conflicting files: Git will mark the conflicting files in your repository. Open these files in a text editor to locate the conflict markers (<<<<<<<, =======, and >>>>>>>).
Resolve conflicts manually: Edit the conflicting sections, keeping the desired changes and removing the conflict markers. Alternatively, you can use a visual merge tool like git mergetool to assist in resolving conflicts.
Commit the changes: After resolving the conflicts, save the file, and stage it using git add <file>. Finally, commit the changes with git commit.

3. Detached HEAD State

The "detached HEAD" state occurs when you checkout a specific commit instead of a branch. This state can make it difficult to work with branches and commit changes. Here's how to recover from a detached HEAD state:

Create a new branch: Create a new branch at the current commit using git branch <new-branch-name>. This branch will be based on the commit you are currently on.
Checkout the new branch: Switch to the newly created branch with git checkout <new-branch-name>. You can now continue working on this branch.
Optional: Merge or rebase changes: If you have uncommitted changes in the detached HEAD state that you want to include in the new branch, you can merge or rebase those changes onto the new branch.

4. Untracked Files

Untracked files are files that Git is not currently tracking. They are typically new files that you have added to your project. To start tracking these files, use the following steps:

Add the files to the Git index: Stage the untracked files using git add <file> or git add . to add all untracked files in the current directory.
Commit the changes: After adding the files to the Git index, commit the changes using git commit -m "Your commit message".

5. Authentication Failed

If you encounter authentication errors when pushing or pulling from a remote repository, it typically means there is an issue with your authentication credentials. Here's what you can do:

Verify credentials: Double-check that you have entered the correct username and password or SSH key for the remote repository.
Update authentication method: If you're using HTTPS, consider switching to SSH authentication for a more secure and seamless experience. Follow the appropriate documentation to set up SSH keys for your Git hosting provider.
Clear cached credentials: If you have recently changed your authentication credentials, try clearing the cached credentials on your local machine using the appropriate methods for your operating system.
Check firewall or proxy settings: If you're behind a firewall or using a proxy, ensure that your Git client is configured correctly to work with your network settings.

Conclusion

Troubleshooting common Git issues is an essential skill for any developer using version control. By understanding these common issues and their solutions, you can overcome obstacles and maintain a smooth Git workflow. Remember to double-check repository URLs, resolve merge conflicts carefully, recover from detached HEAD states, track untracked files, and verify authentication credentials to address common Git issues effectively. With these troubleshooting techniques in your toolkit, you'll be well-equipped to navigate Git-related challenges with confidence.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

Integrating GitHub with Other Tools

Pratik Kale — Sun, 02 Jul 2023 18:57:04 +0000

Welcome to the sixteenth blog of the series!

GitHub is not just a code hosting platform; it also provides seamless integration with a wide range of tools and services. These integrations can enhance your development workflow, automate tasks, and improve collaboration. In this blog post, we will explore some of the ways you can integrate GitHub with other tools and make the most out of your development process.

Continuous Integration and Deployment (CI/CD)

One of the most common integrations with GitHub is setting up Continuous Integration and Deployment (CI/CD) pipelines. CI/CD allows you to automate the building, testing, and deployment of your applications. Here's an example of integrating GitHub with popular CI/CD tools:

1. GitHub Actions

GitHub Actions is a powerful built-in CI/CD solution provided by GitHub. It allows you to define workflows using YAML files directly in your repository. Here's a basic example of a GitHub Actions workflow:

name: CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Build and test
      run: |
        npm install
        npm run build
        npm run test

    - name: Deploy
      run: |
        # Add deployment steps here

With this configuration, every push to the main branch will trigger the defined workflow, including building, testing, and deploying your application.

2. Jenkins

Jenkins is a popular open-source CI/CD tool that integrates well with GitHub. You can set up Jenkins to listen for webhooks from your GitHub repository and trigger builds automatically. Here's a high-level overview of integrating Jenkins with GitHub:

Install and configure Jenkins on your server or use a hosted Jenkins service.
Create a new Jenkins job and configure it to pull code from your GitHub repository.
Configure the job to execute build commands, run tests, and perform any other necessary tasks.
Add a webhook to your GitHub repository, pointing to the Jenkins server, to trigger builds whenever changes are pushed.

With Jenkins integrated with GitHub, you can automate your build and deployment processes and ensure that your application is continuously tested and deployed.

Project Management and Issue Tracking

GitHub also provides robust project management and issue tracking capabilities. However, you may prefer to use other tools for project management, such as Jira or Trello. Thankfully, GitHub offers integrations to sync your GitHub issues with these external tools.

1. Jira Integration

If your team uses Jira for project management and issue tracking, you can integrate it with your GitHub repository. The integration allows you to link GitHub issues to Jira issues, enabling seamless collaboration between developers and project managers. To set up the Jira integration:

Install the Jira integration app from the GitHub Marketplace.
Configure the integration by providing your Jira instance URL and authentication details.
Link GitHub issues to Jira issues by mentioning the Jira issue key (e.g., PROJECT-123) in the GitHub issue.

The integration will automatically sync issue details, comments, and status changes between GitHub and Jira, ensuring that both platforms stay up to date.

2. Trello Integration

Trello is another popular project management tool that can be integrated with GitHub. The integration allows you to link GitHub issues to Trello cards, providing a visual representation of your project's progress. Here's how to set up the Trello integration:

Install the Trello Power-Up for GitHub from the Trello Power-Up directory.
Authorize Trello to access your GitHub account and repositories.
Add the GitHub Power-Up to your Trello board.
Link GitHub issues to Trello cards by mentioning the GitHub issue URL in the Trello card's description or comments.

The integration will provide a summary of the linked GitHub issue on the Trello card, making it easy to track progress and collaborate on issues.

Chat and Communication Tools

Collaboration and communication are vital for successful development projects. Integrating GitHub with chat and communication tools can streamline collaboration and ensure that everyone is on the same page.

1. Slack Integration

Slack is a popular team communication platform that can be integrated with GitHub. The integration allows you to receive notifications about GitHub activities, such as pull requests, issues, and deployments, directly in your Slack channels. To set up the Slack integration:

Install the GitHub app from the Slack App Directory.
Authorize the GitHub app to access your GitHub repositories.
Configure the integration by selecting the desired GitHub repositories and Slack channels.

Once configured, you will receive real-time notifications in your Slack channels, keeping your team informed about the latest activities in your GitHub repositories.

2. Microsoft Teams Integration

If your team uses Microsoft Teams for collaboration, you can integrate it with GitHub as well. The integration allows you to receive notifications about GitHub activities in your Teams channels. Here's how to set up the Microsoft Teams integration:

Install the GitHub app from the Microsoft Teams App Store.
Authorize the app to access your GitHub repositories.
Configure the integration by selecting the desired GitHub repositories and Teams channels.

With the integration in place, your Teams channels will receive notifications about events such as pull requests, issue updates, and repository activities.

Conclusion

Integrating GitHub with other tools can significantly improve your development workflow, automate tasks, and enhance collaboration. Whether it's setting up CI/CD pipelines, syncing project management tools, or integrating with chat and communication platforms, GitHub provides a range of options to seamlessly connect with external tools. Explore the integrations discussed in this blog post and find the ones that best suit your team's needs. Streamline your development process, improve collaboration, and take advantage of the rich ecosystem of tools available to enhance your GitHub experience.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

Advanced Git Techniques

Pratik Kale — Sun, 02 Jul 2023 18:45:00 +0000

Welcome to the fifteenth blog of the series!

Git is a powerful version control system that enables efficient collaboration and tracking of code changes. While Git offers a straightforward workflow for everyday use, there are advanced techniques that can further enhance your productivity and flexibility. In this blog post, we will explore some of these advanced Git techniques, including branch management, rebasing, cherry-picking, and interactive staging.

Branch Management

Branching is a fundamental concept in Git that allows you to work on multiple code streams concurrently. Here are a few advanced techniques for managing branches:

Creating a New Branch

To create a new branch, use the git branch command followed by the branch name:

git branch new-feature

This creates a new branch named new-feature based on the current branch you're on.

Switching Between Branches

To switch to a different branch, use the git checkout command:

git checkout new-feature

This switches your working directory to the new-feature branch.

Deleting a Branch

Once you've merged a branch or no longer need it, you can delete it using the git branch -d command:

git branch -d new-feature

Renaming a Branch

To rename a branch, you can use the -m option with the git branch command:

git branch -m new-name

Rebasing

Rebasing is a technique used to incorporate changes from one branch onto another branch. It allows you to maintain a clean and linear history. Here's an example:

git checkout feature-branch
git rebase main

This rebases the feature-branch onto the main branch, applying the changes from main on top of the feature-branch.

Cherry-picking

Cherry-picking is a technique that allows you to apply a specific commit from one branch onto another branch. Here's how you can do it:

git checkout target-branch
git cherry-pick <commit-hash>

This applies the changes from the specified commit onto the target-branch.

Interactive Staging

Interactive staging allows you to selectively stage changes within a file, providing fine-grained control over what gets committed. Here's how to do it:

git add -p <file-name>

This opens the interactive staging mode, which presents each change within the file. You can choose to stage or skip individual changes based on your requirements.

Git Reflog

Git reflog is a powerful tool that allows you to view the history of branch references, including branches that have been deleted or modified. It can be helpful for recovering lost commits or branches. Use the following command to access the reflog:

git reflog

Git Worktree

Git worktree is a feature that allows you to work on multiple branches simultaneously without switching between directories. It's particularly useful when you need to make changes in one branch while keeping another branch's working directory intact. Here's how to use it:

git worktree add <path> <branch-name>

This creates a new worktree at the specified path, linked to the given branch.

Conclusion

These advanced Git techniques empower you to streamline your workflow, manage branches effectively, and maintain a clean commit history. By mastering techniques such as branch management, rebasing, cherry-picking, interactive staging, and utilizing Git tools like reflog and worktree, you can take full advantage of Git's capabilities. Experiment with these techniques in your projects, and over time, you'll become a more proficient Git user, enabling smoother collaboration and efficient code management.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

GitHub Actions: Automating Your Workflow

Pratik Kale — Sun, 02 Jul 2023 17:51:06 +0000

Welcome to the fourteenth blog of the serires!

GitHub Actions is a powerful automation tool provided by GitHub that allows you to automate various tasks and workflows within your repositories. With GitHub Actions, you can build, test, and deploy your code automatically, saving time and ensuring consistent results. In this blog post, we will explore the capabilities of GitHub Actions, learn how to set up workflows, and showcase examples of common automation scenarios.

Understanding GitHub Actions

GitHub Actions allows you to define custom workflows using YAML files. A workflow consists of one or more jobs, and each job runs on a separate virtual environment called a runner. You can specify the events that trigger the workflow, such as push, pull request, or a scheduled time. Each job can execute a series of steps, which can include running commands, executing scripts, or invoking external actions.

Creating a Workflow

To create a GitHub Actions workflow, follow these steps:

Go to your GitHub repository's page.
Click on the "Actions" tab.
Click on the "Set up a workflow yourself" link or choose a pre-defined workflow template.
GitHub will open a new file in the .github/workflows directory. Provide a meaningful name for the workflow, such as main.yml.
Define the workflow using YAML syntax.

Let's take a look at a simple example of a workflow that runs on every push to the main branch:

name: CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Build and test
        run: |
          npm install
          npm run build
          npm run test

In this example, the workflow is triggered by a push event on the main branch. The build job runs on an ubuntu-latest runner. The steps in the job include checking out the code and performing build and test operations.

Using Actions

GitHub Actions provides a vast marketplace of pre-built actions that you can use in your workflows. Actions are reusable units of code that perform specific tasks. You can find actions for a wide range of use cases, such as deploying to cloud platforms, sending notifications, or running tests.

To use an action in your workflow, you can specify it in the steps section of a job. Here's an example that uses the actions/checkout and actions/npm actions:

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Build and test
        run: |
          npm install
          npm run build
          npm run test

      - name: Deploy to GitHub Pages
        uses: JamesIves/github-pages-deploy-action@4.1.0
        with:
          branch: gh-pages
          folder: dist

In this example, after building and testing the code, the workflow uses the JamesIves/github-pages-deploy-action action to deploy the contents of the dist folder to the gh-pages branch.

Secrets and Environment Variables

GitHub Actions allows you to store and use secrets securely in your workflows. Secrets are encrypted and can be accessed within your workflow using environment variables.

To set up a secret, go to your repository's page, click on "Settings," then "Secrets," and finally "New repository secret." You can then reference the secret in your workflow using the secrets.<secret-name> syntax.

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Set up environment
        run: |
          echo "DATABASE_URL=${{ secrets.DATABASE_URL }}" >> $GITHUB_ENV

In this example, the DATABASE_URL secret is set as an environment variable within the workflow.

Workflow Visualization

GitHub provides a visual representation of your workflows, making it easier to understand the overall process and identify potential issues. You can access the workflow visualization by navigating to the "Actions" tab in your repository and selecting the workflow of interest.

Conclusion

GitHub Actions offers a powerful automation platform that allows you to streamline your development workflows. By defining custom workflows, leveraging pre-built actions, and utilizing secrets and environment variables, you can automate tasks such as building, testing, and deploying your code. Explore the vast marketplace of actions and experiment with different workflows to enhance your development process. GitHub Actions empowers you to save time, increase productivity, and ensure the consistency and quality of your software projects. Start automating your workflows with GitHub Actions today!

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

GitHub Desktop: Simplified Git Workflow

Pratik Kale — Sun, 02 Jul 2023 17:28:22 +0000

Welcome to the thirteenth blog of the series!

GitHub Desktop is a user-friendly application that provides a graphical interface for managing your Git repositories. It simplifies the Git workflow by abstracting away the command-line complexity and providing an intuitive interface to perform common Git operations. In this blog post, we will explore the features of GitHub Desktop, demonstrate how to use them effectively, and showcase how it streamlines your Git workflow.

Installing GitHub Desktop

Before we dive into the features of GitHub Desktop, let's quickly go over the installation process:

Visit the GitHub Desktop website at desktop.github.com.
Download the GitHub Desktop application compatible with your operating system.
Run the installer and follow the on-screen instructions to complete the installation.

Once GitHub Desktop is installed, let's explore its powerful features.

Cloning a Repository

To start working with GitHub Desktop, you need to clone an existing Git repository. Follow these steps to clone a repository:

Launch GitHub Desktop.
Click on the "File" menu and select "Clone Repository."
Choose the repository you want to clone from the list of available options.
Specify the local path where you want to store the repository on your computer.
Click on the "Clone" button.

GitHub Desktop will download the repository to your local machine, allowing you to work with its files and history.

Making Changes and Committing

GitHub Desktop provides an intuitive interface for making changes to your code and committing them to the repository. Here's how to do it:

Open the cloned repository in GitHub Desktop.
Make changes to your code using your preferred code editor.
Switch back to GitHub Desktop and you will see the changes listed under "Changes" tab.
Review the changes and choose the files you want to include in the commit.
Enter a descriptive commit message that explains the changes.
Click on the "Commit" button to create a commit.

GitHub Desktop will create a new commit with your changes and update the repository's history.

Pushing and Pulling

With GitHub Desktop, pushing and pulling changes to and from remote repositories becomes effortless. Here's how to do it:

Pushing Changes

After committing your changes, click on the "Push origin" button at the top right corner of the application.
GitHub Desktop will push your local commits to the remote repository, keeping your local and remote repositories in sync.

Pulling Changes

If there are new changes in the remote repository, GitHub Desktop will notify you.
Click on the "Pull origin" button to fetch and merge the latest changes from the remote repository into your local repository.
GitHub Desktop handles the complexities of pulling and pushing changes, making it easy to collaborate with others on your projects.

Branching and Merging

GitHub Desktop simplifies the process of branching and merging in Git. Here's how to create a new branch and merge it back to the main branch:

Creating a New Branch

Click on the current branch dropdown at the top left corner of the application.
Select "New Branch" from the dropdown menu.
Enter a name for your new branch.
Click on the "Create Branch" button.

Merging Branches

Switch to the branch you want to merge into (e.g., the main branch).
Click on the "Branch" menu and select "Merge into current branch."
Choose the branch you want to merge from the dropdown menu.
Review the changes that will be merged and click on the "Merge Branch" button.

GitHub Desktop streamlines the branching and merging process, allowing you to manage different versions of your code with ease.

Conclusion

GitHub Desktop provides a user-friendly interface for managing your Git repositories. With its intuitive features, you can clone repositories, make changes, commit, push and pull changes, create branches, and merge them effortlessly. By abstracting away the complexities of the command line, GitHub Desktop simplifies the Git workflow and empowers developers to focus on their code and collaboration.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

GitKraken Client: Advanced Features

Pratik Kale — Sun, 02 Jul 2023 17:14:42 +0000

Welcome to the twelth blog of the series!

GitKraken is a popular Git client that provides a visually appealing and user-friendly interface for managing your Git repositories. It offers a range of advanced features that can greatly enhance your Git workflow. In this blog post, we will explore some of the advanced features of GitKraken and demonstrate how to use them effectively.

Refer to the previous blog for installation and overview of the basic features.

Visualizing Repository History

One of the key advantages of GitKraken is its ability to visually represent the history of your Git repository. This makes it easier to understand and navigate through complex branching and merging structures. Here's how you can visualize your repository history in GitKraken:

Launch GitKraken.
Click on "File" in the menu bar and select "Open Repository".
Choose the local repository you want to visualize, or clone a remote repository.
GitKraken will display the repository graph, showing branches, commits, and their relationships.

By visually representing your repository history, GitKraken helps you gain a better understanding of your codebase and its evolution over time.

Resolving Merge Conflicts

Merge conflicts can occur when Git is unable to automatically merge changes from different branches. GitKraken provides a streamlined interface for resolving merge conflicts, making the process more intuitive. Follow these steps to resolve merge conflicts in GitKraken:

When a merge conflict occurs, GitKraken will display a visual representation of the conflicting files with markers indicating the conflicts.
Double-click on a file to open the merge conflict resolution view.
GitKraken will present the conflicting sections of the file side by side, allowing you to manually edit and resolve the conflicts.
Once you have resolved the conflicts, save the file.
Click on the "Mark as resolved" button in the top-right corner of the merge conflict resolution view.

GitKraken will update the file and mark the conflict as resolved in the repository graph.

Working with Pull Requests

GitKraken simplifies the process of creating and managing pull requests, making it easier to collaborate with your team. Here's how you can work with pull requests in GitKraken:

Open your repository in GitKraken.
Click on the "Pull Requests" tab in the left sidebar.
Click on the "New Pull Request" button.
Select the source and target branches for the pull request.
Add a title and description for the pull request.
Optionally, assign reviewers and add labels to provide more context.
Click on the "Create Pull Request" button.

GitKraken will create the pull request and display it in the pull request list. You can view and manage your pull requests directly within GitKraken.

Integrating with Issue Tracking Systems

GitKraken offers seamless integration with popular issue tracking systems such as Jira, GitHub Issues, and GitLab Issues. This integration allows you to view and manage your project's issues and track their progress without leaving the GitKraken interface. Here's how you can integrate GitKraken with an issue tracking system:

Open your repository in GitKraken.
Click on the "Issue Tracking" tab in the left sidebar.
Select the issue tracking system you want to integrate with.
Follow the prompts to authenticate and connect GitKraken to your chosen system.
Once connected, you will be able to view and manage issues directly within GitKraken.

Integrating GitKraken with an issue tracking system streamlines your development workflow by providing a centralized view of issues and their related code changes.

Conclusion

GitKraken is a feature-rich Git client that offers a range of advanced features to enhance your Git workflow. By visualizing repository history, resolving merge conflicts, working with pull requests, and integrating with issue tracking systems, GitKraken provides a comprehensive and user-friendly interface for managing your Git repositories. Install GitKraken today and leverage its advanced features to streamline your development process and collaborate more efficiently with your team.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

GitKraken Client: Getting Started

Pratik Kale — Sun, 02 Jul 2023 17:00:27 +0000

Welcome to the eleventh blog of the series!

In this blog we will explore GitKraken Client.GitKraken is a powerful cross-platform Git client that provides an intuitive and visually appealing interface for managing your Git repositories. With features like seamless Git integration, a robust code editor, and collaborative tools, GitKraken simplifies the Git workflow and enhances productivity. In this blog post, we will guide you through getting started with GitKraken, explore its key features, and discuss some of the pro features available.

Installing GitKraken

To get started with GitKraken, follow these steps to install it on your machine:

Visit the GitKraken website at gitkraken.com.
Click on the "Download" button to download the installer for your operating system (Windows, macOS, or Linux).
Run the installer and follow the on-screen instructions to complete the installation.

Once GitKraken is installed, launch the application to begin.

Cloning a Repository

To start working with a Git repository in GitKraken, you can clone an existing repository from a remote server. Follow these steps to clone a repository:

Click on the "Clone a Repo" button on the GitKraken home screen.
Enter the URL of the remote repository you want to clone.
Choose a local directory where you want to store the cloned repository.
Click on the "Clone the repo!" button.

GitKraken will clone the repository to your local machine, allowing you to start working with its files and history.

Navigating the Interface

Once you have a repository open in GitKraken, you will notice its intuitive and user-friendly interface. Here are some key elements of the interface:

Commit graph: The commit graph visually represents the commit history of the repository, showing branches, merges, and commits.
File tree: The file tree displays the directory structure of the repository, allowing you to navigate and manage files.
Diff view: The diff view shows the differences between file versions, highlighting added, modified, and deleted lines.
Branches: The branches panel lists all the branches in the repository, allowing you to create, switch, and merge branches.
Pull request and issue integration: GitKraken seamlessly integrates with popular hosting services like GitHub and GitLab, providing a streamlined experience for managing pull requests and issues.

Committing Changes

To commit changes to your repository in GitKraken, follow these steps:

Make changes to your files in the code editor or any other external editor.
In the GitKraken interface, stage the files you want to include in the commit by clicking on the checkbox next to each file.
Enter a commit message that describes the changes you made.
Click on the "Commit" button to create the commit.

GitKraken will create a new commit with your changes and update the commit graph accordingly.

Pro Features of GitKraken

GitKraken offers additional advanced features through its pro version. Some of the notable pro features include:

GitKraken Boards: A powerful kanban-style task and issue tracking system to manage your development projects seamlessly.
GitKraken Timelines: A visual timeline that provides a clear overview of your repository's commit history and helps identify trends and patterns.
GitKraken Git Integration: Deep integrations with popular development tools like Jira, Trello, Slack, and more, enabling smooth collaboration and project management.

To unlock the pro version you can use the GitHub Student Developer Pack. GitKraken is free as long as you are student.

Conclusion

GitKraken is an exceptional Git client that offers a visually appealing and user-friendly interface for managing your Git repositories. By following the steps outlined in this blog post, you can get started with GitKraken, clone repositories, navigate the interface, and commit changes to your codebase. The pro features of GitKraken, including GitKraken Boards, Timelines, and Git Integration, further enhance your productivity and collaboration capabilities. Download GitKraken today and experience the power and simplicity it brings to your Git workflow.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

Git Lens: Advanced Git Features

Pratik Kale — Sun, 02 Jul 2023 16:36:41 +0000

Welcome to the tenth blog of the series!
Now that we have covered Git, GitHub and how to collborate. Let's look at Git Lens a Visual Studio extention which enhances your Git workflow by providing advanced features and insights directly within the editor. It offers a wealth of functionalities, including annotations, code lens, blame annotations, and much more. In this blog post, we will explore the various features of Git Lens, demonstrate how to use them effectively, and discuss some of the pro features available.

Installing Git Lens

Before we dive into the features of Git Lens, let's quickly go over the installation process:

Launch Visual Studio Code.
Open the Extensions view by clicking on the square icon on the left sidebar or by using the shortcut Ctrl+Shift+X.
Search for "Git Lens - Git supercharged" in the Extensions Marketplace.
Click on the "Install" button next to the Git Lens .
Wait for the installation to complete, and then click on the "Reload" button to activate the extension.

With Git Lens installed and activated, let's explore its powerful features.

Annotating Code with Git Blame

Git Lens allows you to view Git blame annotations directly in your code, providing insights into who last modified each line. To enable Git blame annotations:

Open a file in Visual Studio Code.
Right-click on the editor or use the command palette (Ctrl+Shift+P).
Search for "Git Lens: Toggle Line Blame Annotations" and select it.

Git Lens will display annotations alongside each line of code, showing the author and commit details.

Exploring Code History

With Git Lens, you can effortlessly explore the history of a file, view commits, and see detailed information about each commit. Follow these steps to access code history:

Open a file in Visual Studio Code.
Right-click on the editor or use the command palette (Ctrl+Shift+P).
Search for "Git Lens: Show File History" and select it.

Git Lens will display a timeline of commits related to the file. Clicking on a commit will show you the commit message, author, and other relevant information.

Viewing Code Lens

Code Lens is a powerful feature of Git Lens that provides additional contextual information about your code. It displays Git blame annotations, recent commit messages, and the number of references to a particular code block. To enable code lens:

Open a file in Visual Studio Code.
Look for annotations above code blocks, showing Git blame information and commit details.
Hovering over the annotations will reveal additional options, such as viewing the full commit message or navigating to the commit.

Code Lens provides valuable insights into the origin and history of your code, helping you understand its context and evolution.

Pro Features of Git Lens

Git Lens offers additional advanced features through its pro version. Some of the notable pro features include:

Code authorship: See author statistics, including lines of code contributed and number of commits.
Advanced search: Perform advanced searches within your Git repository, such as searching for specific code snippets or commit messages.
File comparisons: Compare the differences between different versions of a file to gain a deeper understanding of code changes. To unlock these pro features, you can purchase a license directly within the extension.

To unlock the pro version you can use the GitHub Student Developer Pack. Git Lens pro is free as long as you are student.

Conclusion

Git Lens is a valuable extension for Visual Studio Code that enhances your Git workflow and provides advanced features directly within the editor. With Git blame annotations, code history exploration, and code lens, you gain insights into the evolution and context of your code. The pro features of Git Lens offer additional capabilities, including code authorship statistics, advanced search functionality, and file comparisons. Install Git Lens today and take advantage of its powerful features to streamline your Git workflow and gain a deeper understanding of your codebase.

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

GitHub Pages: Custom Domains and SSL

Pratik Kale — Sun, 02 Jul 2023 14:10:45 +0000

Welcome to the ninth blog of the series!
In the last blog we created our first website with GitHub Pages.
It was deployed on the domain .github.io, but did you know that you can use a custom domain name for your GitHub Pages site? In addition, you can secure your website with SSL (Secure Sockets Layer) to ensure a safe and encrypted connection. In this blog post, we will explore how to set up a custom domain and enable SSL for your GitHub Pages site.

Prerequisites

Before we begin, make sure you have the following:

A GitHub account. You can create one for free at github.com.
A registered domain name from a domain registrar (e.g., Namecheap, GoDaddy).

Setting Up a Custom Domain

To use a custom domain name for your GitHub Pages site, follow these steps:

GitHub Pages: Custom Domains and SSL
GitHub Pages provides a convenient way to host your static websites, but did you know that you can use a custom domain name for your GitHub Pages site? In addition, you can secure your website with SSL (Secure Sockets Layer) to ensure a safe and encrypted connection. In this blog post, we will explore how to set up a custom domain and enable SSL for your GitHub Pages site.

Prerequisites

Before we begin, make sure you have the following:

A GitHub account. You can create one for free at github.com.
A registered domain name from a domain registrar (e.g., Namecheap, GoDaddy).

To register your domain you can use the free domain TLD's available from the GitHub Student Developer Pack. For more information you can refer the blog below.

GitHub Student Developer Pack: Overview

Pratik Kale ・ Jul 1 '23

#github #community #writing

Setting Up a Custom Domain

To use a custom domain name for your GitHub Pages site, follow these steps:

Log in to your domain registrar's website and locate the DNS management settings for your domain.
Add a CNAME record for your custom domain. The CNAME value should be <your-username>.github.io, where <your-username> is your GitHub username.
Save the DNS changes and wait for the DNS propagation to take effect. This may take some time, usually up to 24 hours.

Once the DNS changes have propagated, you can proceed with configuring your GitHub repository to use the custom domain.

Go to your GitHub repository's page.
Click on the "Settings" tab.
Scroll down to the "GitHub Pages" section.
In the "Custom domain" field, enter your custom domain name (e.g., www.yourdomain.com).
Click on the "Save" button.

GitHub Pages will automatically configure the necessary settings to associate your custom domain with your repository. You can now access your GitHub Pages site using your custom domain.

Enabling SSL for Custom Domains

Enabling SSL (Secure Sockets Layer) for your custom domain ensures that your website is accessed securely over HTTPS. To enable SSL for your GitHub Pages site, you can use a service like Cloudflare or GitHub's Automated Certificate Management (ACM).

Using Cloudflare for SSL

Sign up for a Cloudflare account.
Add your custom domain to Cloudflare and follow their instructions to set up your DNS.
Once your custom domain is set up on Cloudflare, go to the "SSL/TLS" section.
Choose the SSL/TLS encryption mode to "Full" or "Full (Strict)".
Cloudflare will automatically provide an SSL certificate for your domain.

Using GitHub's Automated Certificate Management (ACM)

GitHub's ACM provides a simple way to enable SSL for your custom domain directly through your GitHub repository settings. Here's how to enable it:

Go to your GitHub repository's page.
Click on the "Settings" tab.
Scroll down to the "GitHub Pages" section.
In the "Custom domain" field, enter your custom domain name (e.g., www.yourdomain.com).
Click on the "Enforce HTTPS" checkbox.

GitHub will automatically generate and manage an SSL certificate for your custom domain, allowing your site to be accessed securely over HTTPS.

Verifying SSL

To verify that SSL is enabled for your custom domain, you can visit your website using the HTTPS protocol. For example, enter https://www.yourdomain.com in your web browser. If the website loads without any security warnings, SSL is successfully enabled.

Conclusion

Setting up a custom domain and enabling SSL for your GitHub Pages site can significantly enhance its professional appearance and security. By following the steps outlined in this blog post, you can easily configure your custom domain and ensure secure access to your website. Whether you're showcasing a personal portfolio or hosting a project website, custom domains and SSL provide a seamless and secure experience for your visitors. Start leveraging the power of custom domains and SSL with GitHub Pages and elevate your online presence!

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail

GitHub Pages: Building Your First Website

Pratik Kale — Sun, 02 Jul 2023 13:47:55 +0000

Welcome to the eighth blog of the series!
Now that we have a basic idea of Git & GitHub let's use is it in a real world scenario. In this blog we will explore GitHub Pages and see how you can build and host a simple portfolio website.

In today's digital age, having a personal website has become more than just a trend; it's a necessity. Whether you're an aspiring entrepreneur, a creative professional, or even a job seeker, a personal website can serve as your online identity and give you a competitive edge in the virtual realm. It's a place where you can showcase your skills, share your achievements, and connect with like-minded individuals from around the world.

GitHub Pages makes it very easy to host a static website with a few click!

Prerequisites

A GitHub account. You can create one for free at github.com.
Basic knowledge of HTML, CSS, and Git.

Setting Up a Repository

To get started with GitHub Pages, you need a repository to host your website. Follow these steps to create a new repository:

Log in to your GitHub account and click on the "+" button at the top right corner of the page.
Select "New repository" from the dropdown menu.
Choose a repository name. For GitHub Pages, it's recommended to name it .github.io, where is your GitHub username.
Optionally, add a description for your repository.
Select "Public"
Check the box to initialize the repository with a README file.
Click on the "Create repository" button.

Congratulations! You have created a new repository for your website.

Creating Your Website

Now that you have a repository, it's time to create your website. Follow these steps to get started:

Open your preferred code editor and create a new HTML file named index.html.
Add the basic structure of an HTML file:

<!DOCTYPE html>
<html>
<head>
  <title>Your Website Title</title>
</head>
<body>
  <!-- Your website content goes here -->
</body>
</html>

I have given an example of index.html file. But you can write code according to your linking and create a portofolio. You can also use templates which are readily available. You can refer the link below for few such examples.
https://html5up.net/

Also you can use themes offered by GitHub.

In your repository's settings, under the GitHub Pages section, click on the "Change theme" button.
Browse through the available themes and select one that suits your website.
Customize the theme settings, such as color scheme or layout, if desired.
Your website will automatically update with the new theme.

Deploying Your Website with GitHub Pages

With your website code ready, it's time to deploy it using GitHub Pages. Follow these steps:

Go to your repository's page on GitHub.
Click on the "Settings" tab.
Scroll down to the "GitHub Pages" section.
Select the branch you want to use for GitHub Pages. Typically, you should choose the main branch.
Optionally, choose a folder in your repository if your website files are located in a subdirectory.
Click on the "Save" button.

GitHub Pages will build and deploy your website. Once the process is complete, you will see a green success message with the URL of your deployed website. It may take a few moments for the changes to take effect.

Updating your website

To update your website, follow these steps:

Make changes to your website's HTML, CSS, or other assets in your code editor.
Save the changes.
Commit and push the changes to your GitHub repository using Git commands or a Git client.

GitHub Pages will automatically rebuild and update your website with the latest changes.

Conclusion

GitHub Pages provides an excellent platform for hosting your static websites with ease. By following the steps outlined in this blog post, you can set up your repository, create your website, and deploy it using GitHub Pages. With customization options like custom domains and themes, you can personalize your website to reflect your style and brand. GitHub Pages is a powerful tool that empowers developers to showcase their projects, create personal websites, and share their work with the world. Start building your first website with GitHub Pages and take your web presence to new heights!

Thank you for reading and do let me know your thoughts in comments!

Connect With Me :

Pratik KaleFollow

Software Enginner @ Impulsive Web | Organizer @GDG Cloud Pune | Google DSC Lead '21 | Tech Geek 💻 | Learner 📔

Website | Twitter | Instagram | Mail