DEV Community: Lisa Tagliaferri

Happy Hacktoberfest from Sourcegraph 🍂

Lisa Tagliaferri — Tue, 05 Oct 2021 21:16:10 +0000

We on the Sourcegraph team are so excited to be a Hacktoberfest Community Partner to celebrate open source throughout October.

Partnering with the community to invite more developers into open source is really important to us, and we are so thrilled to welcome contributors to open pull requests on our repositories.

Accepting contributors to Sourcegraph

The Sourcegraph team has put together a Good First Issues GitHub board that will help Hacktoberfest contributors be able to contribute to our repos.

In the board, you will find a number of Issues across different technologies, as well as technical troubleshooting tutorials that you can contribute to Sourcegraph Learn.

We also have a contributing guide in the main sourcegraph/sourcegraph repository to support you in making pull requests on the project.

Give back to the community by helping devs recover from errors

Sourcegraph Learn is participating in Hacktoberfest through inviting the community to contribute troubleshooting tutorials in popular programming languages and more.

Check out our open issues to review what we are looking for help with this month.

We have a dedicated Hacktoberfest 2021 contributor guide that provides step-by-step directions so you can open up your pull request and contribute directly to open source and help developers troubleshoot their code!

Earn Sourcegraph swag

For Hacktoberfest 2021, we are happy to share that we will be offering the first 50 successfully merged pull request contributors with a Sourcegraph swag package. We'll provide details to contributors directly.

Catch our presentation as part of the Hacktoberfest KickOff celebration.

How To Install WordPress on Ubuntu 20.04 with a LAMP Stack

Lisa Tagliaferri — Wed, 08 Jul 2020 17:55:44 +0000

Introduction

WordPress is an extremely popular open-source technology for making websites and blogs on the internet today. Used by 63% of all websites that use a content management system (CMS), WordPress sites represent 36% of all websites that are currently online.

There are many different approaches to getting access to WordPress and some setup processes are more complex than others. This tutorial is intended for those who desire to install and administer a Wordpress instance on an unmanaged cloud server via the command line. Though this approach requires more steps than a ready-made WordPress installation, it offers administrators greater control over their WordPress environment.

Depending on your needs and goals, you may find other options that are more suitable. As open-source software, WordPress can be freely downloaded and installed, but to be available on the web, you will likely need to purchase cloud infrastructure and a domain name. Continue following this guide if you are interested in working through the server-side installation and set up of a WordPress site.

This tutorial will be using a LAMP (Linux, Apache, MySQL, and PHP) stack, which is one option for a server architecture that supports WordPress by providing the Linux operating system, Apache web server, MySQL database, and PHP programming language. We’ll install and set up WordPress via LAMP on a Linux Ubuntu 20.04 server.

Prerequisites

In order to complete this tutorial, you will need access to an Ubuntu 20.04 server and will need to complete these steps before beginning this guide:

Set up your server by following our Ubuntu 20.04 initial server setup guide, and ensure you have a non-root sudo user.
Install a LAMP stack by following our LAMP guide to install and configure this software.
Secure your site: WordPress takes in user input and stores user data, so it is important for it to have a layer of security. TLS/SSL is the technology that allows you to encrypt the traffic from your site so that your and your users’ connection is secure. Here are two options available to you to meet this requirement:
- If you have a domain name... you can secure your site with Let’s Encrypt, which provides free, trusted certificates. Follow our Let’s Encrypt guide for Apache to set this up.
- If you do not have a domain... and you are just using this configuration for testing or personal use, you can use a self-signed certificate instead. This provides the same type of encryption, but without the domain validation. Follow our self-signed SSL guide for Apache to get set up.

When you are finished with the setup steps, log into your server as your sudo user and continue below.

Step 1 — Creating a MySQL Database and User for WordPress

The first step that we will take is a preparatory one. WordPress uses MySQL to manage and store site and user information. We have MySQL installed already, but we need to make a database and a user for WordPress to use.

To get started, log into the MySQL root (administrative) account by issuing this command (note that this is not the root user of your server):

mysql -u root -p

You will be prompted for the password you set for the MySQL root account when you installed the software.

Note: If you cannot access your MySQL database via root, as a sudo user you can update your root user’s password by logging into the database like so:

sudo mysql -u root

Once you receive the MySQL prompt, you can update the root user’s password. Here, replace new_password with a strong password of your choosing.

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'new_password';

You may now type EXIT; and can log back into the database via password with the following command:

mysql -u root -p

Within the database, we can create an exclusive database for WordPress to control. You can call this whatever you would like, but we will be using the name wordpress in this guide. Create the database for WordPress by typing:

CREATE DATABASE wordpress DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Note: Every MySQL statement must end in a semi-colon (;). Check to make sure this is present if you are running into any issues.

Next, we are going to create a separate MySQL user account that we will use exclusively to operate our new database. Creating specific databases and accounts can support us from a management and security standpoint. We will use the name wordpressuser in this guide, but feel free to use whatever name is relevant for you.

We are going to create this account, set a password, and grant access to the database we created. We can do this by typing the following command. Remember to choose a strong password here for your database user where we have password:

CREATE USER 'wordpressuser'@'%' IDENTIFIED WITH mysql_native_password BY 'password';

Next, let the database know that our wordpressuser should have complete access to the database we set up:

GRANT ALL ON wordpress.* TO 'wordpressuser'@'%';

You now have a database and user account, each made specifically for WordPress. We need to flush the privileges so that the current instance of MySQL knows about the recent changes we’ve made:

FLUSH PRIVILEGES;

Exit out of MySQL by typing:

EXIT;

In the next step, we’ll lay some foundations for WordPress plugins by downloading PHP extensions for our server.

Step 2 — Installing Additional PHP Extensions

When setting up our LAMP stack, we only required a very minimal set of extensions in order to get PHP to communicate with MySQL. WordPress and many of its plugins leverage additional PHP extensions.

We can download and install some of the most popular PHP extensions for use with WordPress by typing:

sudo apt update
sudo apt install php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip

This will lay the groundwork for installing additional plugins into our WordPress site.

Note: Each WordPress plugin has its own set of requirements. Some may require additional PHP packages to be installed. Check your plugin documentation to discover its PHP requirements. If they are available, they can be installed with apt as demonstrated above.

We will need to restart Apache to load these new extensions, we’ll be doing more configurations on Apache in the next section, so you can wait until then, or restart now to complete the PHP extension process.

sudo systemctl restart apache2

Step 3 — Adjusting Apache's Configuration to Allow for .htaccess Overrides and Rewrites

Next, we will be making a few minor adjustments to our Apache configuration. Based on the prerequisite tutorials, you should have a configuration file for your site in the /etc/apache2/sites-available/ directory.

In this guide, we'll use /etc/apache2/sites-available/wordpress.conf as an example here, but you should substitute the path to your configuration file where appropriate. Additionally, we will use /var/www/wordpress as the root directory of our WordPress install. You should use the web root specified in your own configuration. If you followed our LAMP tutorial, it may be your domain name instead of wordpress in both of these instances.

Note: It's possible you are using the 000-default.conf default configuration (with /var/www/html as your web root). This is fine to use if you’re only going to host one website on this server. If not, it’s better to split the necessary configuration into logical chunks, one file per site.

With our paths identified, we can move onto working with .htaccess so that Apache can handle configuration changes on a per-directory basis.

Enabling .htaccess Overrides

Currently, the use of .htaccess files is disabled. WordPress and many WordPress plugins use these files extensively for in-directory tweaks to the web server’s behavior.

Open the Apache configuration file for your website with a text editor like nano.

sudo nano /etc/apache2/sites-available/wordpress.conf

To allow .htaccess files, we need to set the AllowOverride directive within a Directory block pointing to our document root. Add the following block of text inside the VirtualHost block in your configuration file, making sure to use the correct web root directory:

<Directory /var/www/wordpress/>
    AllowOverride All
</Directory>

When you are finished, save and close the file. In nano, you can do this by pressing CTRL and X together, then Y, then ENTER.

Enabling the Rewrite Module

Next, we can enable mod_rewrite so that we can utilize the WordPress permalink feature:

sudo a2enmod rewrite

This allows you to have more human-readable permalinks to your posts, like the following two examples:

http://example.com/2012/post-name/
http://example.com/2012/12/30/post-name

The a2enmod command calls a script that enables the specified module within the Apache configuration.

Enabling the Changes

Before we implement the changes we’ve made, check to make sure we haven’t made any syntax errors by running the following test.

sudo apache2ctl configtest

You may receive output like the following:

AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.1.1. Set the 'ServerName' directive globally to suppress this message
Syntax OK

If you wish to suppress the top line, just add a ServerName directive to your main (global) Apache configuration file at /etc/apache2/apache2.conf. The ServerName can be your server’s domain or IP address. This is just a message, however, and doesn’t affect the functionality of your site. As long as the output contains Syntax OK, you are ready to continue.

Restart Apache to implement the changes. Make sure to restart now even if you have restarted earlier in this tutorial.

sudo systemctl restart apache2

Next, we will download and set up WordPress itself.

Step 4 — Downloading WordPress

Now that our server software is configured, we can download and set up WordPress. For security reasons in particular, it is always recommended to get the latest version of WordPress from their site.

Change into a writable directory (we recommend a temporary one like /tmp) and download the compressed release.

cd /tmp
curl -O https://wordpress.org/latest.tar.gz

Extract the compressed file to create the WordPress directory structure:

tar xzvf latest.tar.gz

We will be moving these files into our document root momentarily. Before we do, we can add a dummy .htaccess file so that this will be available for WordPress to use later.

Create the file by typing:

touch /tmp/wordpress/.htaccess

We’ll also copy over the sample configuration file to the filename that WordPress reads:

cp /tmp/wordpress/wp-config-sample.php /tmp/wordpress/wp-config.php

We can also create the upgrade directory, so that WordPress won’t run into permissions issues when trying to do this on its own following an update to its software:

mkdir /tmp/wordpress/wp-content/upgrade

Now, we can copy the entire contents of the directory into our document root. We are using a dot at the end of our source directory to indicate that everything within the directory should be copied, including hidden files (like the .htaccess file we created):

sudo cp -a /tmp/wordpress/. /var/www/wordpress

Ensure that you replace the /var/www/wordpress directory with the directory you have set up on your server.

Step 5 — Configuring the WordPress Directory

Before we do the web-based WordPress setup, we need to adjust some items in our WordPress directory.

Adjusting the Ownership and Permissions

An important step that we need to accomplish is setting up reasonable file permissions and ownership.

We’ll start by giving ownership of all the files to the www-data user and group. This is the user that the Apache web server runs as, and Apache will need to be able to read and write WordPress files in order to serve the website and perform automatic updates.

Update the ownership with the chown command which allows you to modify file ownership. Be sure to point to your server’s relevant directory.

sudo chown -R www-data:www-data /var/www/wordpress

Next we’ll run two find commands to set the correct permissions on the WordPress directories and files:

sudo find /var/www/wordpress/ -type d -exec chmod 750 {} \;
sudo find /var/www/wordpress/ -type f -exec chmod 640 {} \;

These permissions should get you working effectively with WordPress, but note that some plugins and procedures may require additional tweaks.

Setting Up the WordPress Configuration File

Now, we need to make some changes to the main WordPress configuration file.

When we open the file, our first task will be to adjust some secret keys to provide a level of security for our installation. WordPress provides a secure generator for these values so that you do not have to try to come up with good values on your own. These are only used internally, so it won’t hurt usability to have complex, secure values here.

To grab secure values from the WordPress secret key generator, type:

curl -s https://api.wordpress.org/secret-key/1.1/salt/

You will get back unique values that resemble output similar to the block below.

Warning! It is important that you request unique values each time. Do NOT copy the values below!

define('AUTH_KEY',         '1jl/vqfs<XhdXoAPz9 DO NOT COPY THESE VALUES c_j{iwqD^<+c9.k<J@4H');
define('SECURE_AUTH_KEY',  'E2N-h2]Dcvp+aS/p7X DO NOT COPY THESE VALUES {Ka(f;rv?Pxf})CgLi-3');
define('LOGGED_IN_KEY',    'W(50,{W^,OPB%PB<JF DO NOT COPY THESE VALUES 2;y&,2m%3]R6DUth[;88');
define('NONCE_KEY',        'll,4UC)7ua+8<!4VM+ DO NOT COPY THESE VALUES #`DXF+[$atzM7 o^-C7g');
define('AUTH_SALT',        'koMrurzOA+|L_lG}kf DO NOT COPY THESE VALUES  07VC*Lj*lD&?3w!BT#-');
define('SECURE_AUTH_SALT', 'p32*p,]z%LZ+pAu:VY DO NOT COPY THESE VALUES C-?y+K0DK_+F|0h{!_xY');
define('LOGGED_IN_SALT',   'i^/G2W7!-1H2OQ+t$3 DO NOT COPY THESE VALUES t6**bRVFSD[Hi])-qS`|');
define('NONCE_SALT',       'Q6]U:K?j4L%Z]}h^q7 DO NOT COPY THESE VALUES 1% ^qUswWgn+6&xqHN&%');

These are configuration lines that we can paste directly in our configuration file to set secure keys. Copy the output you received now.

Next, open the WordPress configuration file:

sudo nano /var/www/wordpress/wp-config.php

Find the section that contains the example values for those settings.

. . .

define('AUTH_KEY',         'put your unique phrase here');
define('SECURE_AUTH_KEY',  'put your unique phrase here');
define('LOGGED_IN_KEY',    'put your unique phrase here');
define('NONCE_KEY',        'put your unique phrase here');
define('AUTH_SALT',        'put your unique phrase here');
define('SECURE_AUTH_SALT', 'put your unique phrase here');
define('LOGGED_IN_SALT',   'put your unique phrase here');
define('NONCE_SALT',       'put your unique phrase here');

. . .

Delete those lines and paste in the values you copied from the command line:

. . .

define('AUTH_KEY',         'VALUES COPIED FROM THE COMMAND LINE');
define('SECURE_AUTH_KEY',  'VALUES COPIED FROM THE COMMAND LINE');
define('LOGGED_IN_KEY',    'VALUES COPIED FROM THE COMMAND LINE');
define('NONCE_KEY',        'VALUES COPIED FROM THE COMMAND LINE');
define('AUTH_SALT',        'VALUES COPIED FROM THE COMMAND LINE');
define('SECURE_AUTH_SALT', 'VALUES COPIED FROM THE COMMAND LINE');
define('LOGGED_IN_SALT',   'VALUES COPIED FROM THE COMMAND LINE');
define('NONCE_SALT',       'VALUES COPIED FROM THE COMMAND LINE');

. . .

Next, we are going to modify some of the database connection settings at the beginning of the file. You need to adjust the database name, the database user, and the associated password that you configured within MySQL.

The other change we need to make is to set the method that WordPress should use to write to the filesystem. Since we’ve given the web server permission to write where it needs to, we can explicitly set the filesystem method to "direct". Failure to set this with our current settings would result in WordPress prompting for FTP credentials when we perform some actions.

This setting can be added below the database connection settings, or anywhere else in the file:

. . .

// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define( 'DB_NAME', 'wordpress' );

/** MySQL database username */
define( 'DB_USER', 'wordpressuser' );

/** MySQL database password */
define( 'DB_PASSWORD', 'password' );

/** MySQL hostname */
define( 'DB_HOST', 'localhost' );

/** Database Charset to use in creating database tables. */
define( 'DB_CHARSET', 'utf8' );

/** The Database Collate type. Don't change this if in doubt. */
define( 'DB_COLLATE', '' );


. . .

define('FS_METHOD', 'direct');

Save and close the file when you are finished.

Step 6 — Completing the Installation Through the Web Interface

Now that the server configuration is complete, we can complete the installation through the web interface.

In your web browser, navigate to your server’s domain name or public IP address:

https://server_domain_or_IP

Select the language you would like to use:

Next, you will come to the main setup page.

Select a name for your WordPress site and choose a username. It is recommended to choose something unique and avoid common usernames like “admin” for security purposes. A strong password is generated automatically. Save this password or select an alternative strong password.

Enter your email address and select whether you want to discourage search engines from indexing your site:

When you click ahead, you will be taken to a page that prompts you to log in:

Once you log in, you will be taken to the WordPress administration dashboard:

At this point, you can begin to design your WordPress website! If this is your first time using WordPress, explore the interface a bit to get acquainted with your new CMS.

Conclusion

Congratulations, WordPress is now installed and is ready to be used!

At this point you may want to start doing the following:

Choose your permalinks setting for WordPress posts, which can be found in Settings > Permalinks.
Select a new theme in Appearance > Themes.
Install new plugins to increase your site’s functionality under Plugins > Add New.
If you are going to collaborate with others, you may also wish to add additional users at this time under Users > Add New.

You can find additional resources for alternate ways to install WordPress, learn how to install WordPress on different server distributions, automate your WordPress installations, and scale your WordPress sites by checking out the WordPress Community tag on DigitalOcean.

How To Install Git from Source on Ubuntu 20.04

Lisa Tagliaferri — Wed, 01 Jul 2020 20:53:39 +0000

Introduction

Version control systems like Git are essential to modern software development best practices. Versioning allows you to keep track of your software at the source level. You can track changes, revert to previous stages, and branch to create alternate versions of files and directories.

In this guide, we will go through how to install and configure Git on an Ubuntu 20.04 server via source. This provides you with a more flexibility, but takes longer than installing through your package manager (also note that Git will not be maintained through your package manager). Downloading the latest release will also provide you with access to the most recent functionality, and give you greater control over options and customizations.

Prerequisites

This guide was tested on an Ubuntu 20.04 server with a non-root superuser account.

If you need to set this up, you can follow the Initial Server Setup Guide for Ubuntu 20.04.

Step 1 — Confirm Git Preinstallation

Verify the version of Git currently installed on the server:

git --version

If Git is installed, you’ll receive output similar to the following:

git version 2.25.1

Whether or not you have Git installed already, it is worth checking to make sure that you install a more recent version during this process.

Step 2 — Update and Install Dependencies

Before you begin, you need to install the software that Git depends on. This is all available in the default repositories, so we can update our local package index and then install the relevant packages.

sudo apt update
sudo apt install libz-dev libssl-dev libcurl4-gnutls-dev libexpat1-dev gettext cmake gcc

Press y to confirm if prompted. Necessary dependencies should now be installed.

Step 3 — Install Tarball

After you have installed the necessary dependencies, create a temporary directory and move into it. This is where we will download our Git tarball.

mkdir tmp
cd /tmp

From the Git project website, we can navigate to the tarball list available at https://mirrors.edge.kernel.org/pub/software/scm/git/ and download the version you would like. At the time of writing, the most recent version is 2.26.2, so we will download that for demonstration purposes. We’ll use curl and output the file we download to git.tar.gz.

curl -o git.tar.gz https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.26.2.tar.gz

In the next step, we'll work with this tarball.

Step 4 — Unpack Compressed File and Install the Package

Unpack the compressed tarball file:

tar -zxf git.tar.gz

Next, move into the new Git directory:

cd git-*

Now, you can make the package and install it by typing these two commands:

make prefix=/usr/local all
sudo make prefix=/usr/local install

At this point, Git is installed and you can refresh your environment.

Step 5 — Verify New Version of Git

Now, replace the shell process so that the version of Git we just installed will be used:

 exec bash

With this complete, you can be sure that your install was successful by checking the version.

git --version

You should receive output similar to the following, with a more recent number than the preinstalled version of Git.

git version 2.26.2

With Git successfully installed, you can now complete your setup.

Step 6 — Set Up Git

After you are satisfied with your Git version, you should configure Git so that the generated commit messages you make will contain your correct information and support you as you build your software project.

Configuration can be achieved by using the git config command. Specifically, we need to provide our name and email address because Git embeds this information into each commit we do. We can go ahead and add this information by typing:

git config --global user.name "Your Name"
git config --global user.email "youremail@domain.com"

We can display all of the configuration items that have been set by typing:

git config --list

You'll get output to demonstrate that your name and email are set up.

user.name=Your Name
user.email=youremail@domain.com
...

The information you enter is stored in your Git configuration file, which you can optionally edit by hand with a text editor of your choice like this (we’ll use nano):

nano ~/.gitconfig

The file will be similar to the following.

[user]
  name = Your Name
  email = youremail@domain.com

Press CTRL and X, then Y then ENTER to exit the text editor.

There are many other options that you can set, but these are the two essential ones needed. If you skip this step, you’ll likely see warnings when you commit to Git. This makes more work for you because you will then have to revise the commits you have done with the corrected information.

Conclusion

You should now have the most recent available version of Git installed and ready to use on your system.

To learn more about how to use Git, check out these articles and series:

The DigitalOcean Community Weekly: DNS, Docker, K8s Canary Deployments, & More

Lisa Tagliaferri — Fri, 28 Jun 2019 14:53:42 +0000

Welcome to the second edition of The DOCOM Weekly, your weekly digest featuring some of the best content published in and around the DigitalOcean Community.

I’m Lisa, a member on the Developer Education team, and I’m excited about sharing knowledge throughout the developer community. Today’s roundup includes DNS management, speeding up Docker workflows, canary deployments with Istio and Kubernetes, and more!

We’ll begin with our featured posts from the past week on the DigitalOcean Community:

How To Deploy and Manage Your DNS using DNSControl on Ubuntu 18.04

Jamie Scaife with editor Kathryn Hancox walk you through using DNSControl to eliminate many of the pain points of manual DNS management. This tutorial was published through our Write for DOnations program, with funding going to the Electronic Frontier Foundation.

How To Use a Remote Docker Server to Speed Up Your Workflow

This tutorial, written by Kamal Nasser and edited by Brian P. Hogan, helps you get your work done faster by demonstrating how to offload Docker tasks to a remote server so your local machine doesn’t have to do the heavy lifting.

How To Do Canary Deployments With Istio and Kubernetes

If you would like to build out canary deployments with Istio and Kubernetes, you can learn how to do so through reading this tutorial by Kathleen Juell. This article will guide you through creating a canary deployment of a demo Node.js application, providing you with a basis for your own work.

Featured Q&A

The DigitalOcean Community Questions section of our Community site is a space for you to ask a development question or provide an answer for others. Here are some questions on the minds of members of the community from the past week.

If you would like to learn more around cloud infrastructure or software development, or if you need help with troubleshooting, ask a question.

DigitalOcean on DEV

monty5811 shared a quick tutorial on how to create expiring links to an object on DigitalOcean Spaces with Django.

Expiring (Signed) Links with Digital Ocean Spaces

monty5811 ・ Jun 12 '19

#django #digitalocean #python #webdev

David Emily provides a gentle introduction to remote servers with DigitalOcean Droplets in this server setup guide.

Removing Root Login And Other First Steps Ubuntu

David Emily ・ Jun 21 '19

#ubuntu #beginners #linux

DigitalOcean on the Web

Tom Eyckmans details how to set up a KubeRig environment using DigitalOcean’s Kubernetes service in this write-up, KubeRig & DigitalOcean Kubernetes (DOKS).

Adam A. G. Shamblin describes how he installed Kong with Ingress on DigitalOcean Kubernetes in order to evaluate API gateway platforms in his guide Installing Kong w/ Ingress on Kubernetes in DigitalOcean.

Elliot Forbes created a video walkthrough of his DigitalOcean tutorial, How to Deploy a Resilient Go Application to Kubernetes on DigitalOcean.

More to Check Out in the Developer Community

Anxiety Tech 2019 is a mental health conference for the tech industry taking place in New York City in August. Join DigitalOcean’s own Frédéric Harper to learn more about the intersections of mental health and tech and how to advocate for more mental health awareness at work.

Frontend developer Ananya Neogi recently highlighted some of the amazing things that pure HTML can do. Learn more about the unsung markup language by following along:

HTML can do that?

Ananya Neogi ・ Jun 25 '19

#webdev #html

Happy hacking, and see you all next week!

How To Use Git: A Reference Guide

Lisa Tagliaferri — Mon, 07 Jan 2019 20:11:19 +0000

Git Cheat Sheet

Introduction

Teams of developers and open-source software maintainers typically manage their projects through Git, a distributed version control system that supports collaboration.

This cheat sheet-style guide provides a quick reference to commands that are useful for working and collaborating in a Git repository. To install and configure Git, be sure to read “How To Contribute to Open Source: Getting Started with Git.”

How to Use This Guide:

This guide is in cheat sheet format with self-contained command-line snippets.
Jump to any section that is relevant to the task you are trying to complete.
When you see highlighted text in this guide’s commands, keep in mind that this text should refer to the commits and files in your own repository.

Set Up and Initialization

Check your Git version with the following command, which will also confirm that Git is installed.

git --version

You can initialize your current working directory as a Git repository with init.

git init

To copy an existing Git repository hosted remotely, you’ll use git clone with the repo’s URL or server location (in the latter case you will use ssh).

git clone https://www.github.com/username/repo-name

Show your current Git directory’s remote repository.

git remote

For a more verbose output, use the -v flag.

git remote -v

Add the Git upstream, which can be a URL or can be hosted on a server (in the latter case, connect with ssh).

git remote add upstream https://www.github.com/username/repo-name

Staging

When you’ve modified a file and have marked it to go in your next commit, it is considered to be a staged file.

Check the status of your Git repository, including files added that are not staged, and files that are staged.

git status

To stage modified files, use the add command, which you can run multiple times before a commit. If you make subsequent changes that you want included in the next commit, you must run add again.

You can specify the specific file with add.

git add my_script.py

With . you can add all files in the current directory including files that begin with a ..

git add .

You can remove a file from staging while retaining changes within your working directory with reset.

git reset my_script.py

Committing

Once you have staged your updates, you are ready to commit them, which will record changes you have made to the repository.

To commit staged files, you’ll run the commit command with your meaningful commit message so that you can track commits.

git commit -m "Commit message"

You can condense staging all tracked files with committing them in one step.

git commit -am "Commit message"

If you need to modify your commit message, you can do so with the --amend flag.

git commit --amend -m "New commit message"

Branches

A branch in Git is a movable pointer to one of the commits in the repository, it allows you to isolate work and manage feature development and integrations. You can learn more about branches by reading the Git documentation.

List all current branches with the branch command. An asterisk (*) will appear next to your currently active branch.

git branch

Create a new branch. You will remain on your currently active branch until you switch to the new one.

git branch new-branch

Switch to any existing branch and check it out into your current working directory.

git checkout another-branch

You can consolidate the creation and checkout of a new branch by using the -b flag.

git checkout -b new-branch

Rename your branch name.

git branch -m current-branch-name new-branch-name

Merge the specified branch’s history into the one you’re currently working in.

git merge branch-name

Abort the merge, in case there are conflicts.

git merge --abort

You can also select a particular commit to merge with cherry-pick with the string that references the specific commit.

git cherry-pick f7649d0

When you have merged a branch and no longer need the branch, you can delete it.

git branch -d branch-name

If you have not merged a branch to master, but are sure you want to delete it, you can force delete a branch.

git branch -D branch-name

Collaborate and Update

To download changes from another repository, such as the remote upstream, you’ll use fetch.

git fetch upstream

Merge the fetched commits.

git merge upstream/master

Push or transmit your local branch commits to the remote repository branch.

git push origin master

Fetch and merge any commits from the tracking remote branch.

git pull

Inspecting

Display the commit history for the currently active branch.

git log

Show the commits that changed a particular file. This follows the file regardless of file renaming.

git log --follow my_script.py

Show the commits that are on one branch and not on the other. This will show commits on a-branch that are not on b-branch.

git log a-branch..b-branch

Look at reference logs (reflog) to see when the tips of branches and other references were last updated within the repository.

git reflog

Show any object in Git via its commit string or hash in a more human-readable format.

git show de754f5

Show Changes

The git diff command shows changes between commits, branches, and more. You can read more fully about it through the Git documentation.

Compare modified files that are on the staging area.

git diff --staged

Display the diff of what is in a-branch but is not in b-branch.

git diff a-branch..b-branch

Show the diff between two specific commits.

git diff 61ce3e6..e221d9c

Stashing

Sometimes you’ll find that you made changes to some code, but before you finish you have to begin working on something else. You’re not quite ready to commit the changes you have made so far, but you don’t want to lose your work. The git stash command will allow you to save your local modifications and revert back to the working directory that is in line with the most recent HEAD commit.

Stash your current work.

git stash

See what you currently have stashed.

git stash list

Your stashes will be named stash@{0}, stash@{1}, and so on.

Show information about a particular stash.

git stash show stash@{0}

To bring the files in a current stash out of the stash while still retaining the stash, use apply.

git stash apply stash@{0}

If you want to bring files out of a stash, and no longer need the stash, use pop.

git stash pop stash@{0}

If you no longer need the files saved in a particular stash, you can drop the stash.

git stash drop stash@{0}

If you have multiple stashes saved and no longer need to use any of them, you can use clear to remove them.

git stash clear

Ignoring Files

If you want to keep files in your local Git directory, but do not want to commit them to the project, you can add these files to your .gitignore file so that they do not cause conflicts.

Use a text editor such as nano to add files to the .gitignore file.

nano .gitignore

To see examples of .gitignore files, you can look at GitHub’s .gitignore template repo.

Rebasing

A rebase allows us to move branches around by changing the commit that they are based on. With rebasing, you can squash or reword commits.

You can start a rebase by either calling the number of commits you have made that you want to rebase (5 in the case below).

git rebase -i HEAD~5

Alternatively, you can rebase based on a particular commit string or hash.

git rebase -i 074a4e5

Once you have squashed or reworded commits, you can complete the rebase of your branch on top of the latest version of the project’s upstream code.

git rebase upstream/master

To learn more about rebasing and updating, you can read How To Rebase and Update a Pull Request, which is also applicable to any type of commit.

Resetting

Sometimes, including after a rebase, you need to reset your working tree. You can reset to a particular commit, and delete all changes , with the following command.

git reset --hard 1fc6665

To force push your last known non-conflicting commit to the origin repository, you’ll need to use --force.

Warning: Force pushing to master is often frowned upon unless there is a really important reason for doing it. Use sparingly when working on your own repositories, and work to avoid this when you’re collaborating.

git push --force origin master

To remove local untracked files and subdirectories from the Git directory for a clean working branch, you can use git clean.

git clean -f -d

If you need to modify your local repository so that it looks like the current upstream master (that is, there are too many conflicts), you can perform a hard reset.

Note: Performing this command will make your local repository look exactly like the upstream. Any commits you have made but that were not pulled into the upstream will be destroyed.

git reset --hard upstream/master

Conclusion

This guide covers some of the more common Git commands you may use when managing repositories and collaborating on software.

You can learn more about open-source software and collaboration in our Introduction to Open Source tutorial series:

There are many more commands and variations that you may find useful as part of your work with Git. To learn more about all of your available options, you can run:

git --help

To receive useful information. You can also read more about Git and look at Git’s documentation from the official Git website.

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License