DEV Community: Deepika Banoth

Understanding WebSockets

Deepika Banoth — Mon, 27 Apr 2020 05:09:36 +0000

What is WebSocket?

Websocket is that protocol which offers interactive bi-directional communication session between the server and the client over a single TCP connection.

This means server can actively send messages to the client at any time, and also the client can send messages to the server without doing full HTTP requests each time.

This is made possible by providing a normalized way for the server to send content to the browser without being requested by the client, and allowing information to be pushed back and forth while keeping the connection open.

Why to use WebSocket?

As Websocket provides full-duplex communication, this can be used:

When your application involve multiple users communicating with each other.
When your application is a window to server-side data that’s constantly changing. Few scenarios where Websocket can be used:

Ongoing Updates: When a client wants ongoing updates, using WebSocket is good. As there is a good fit when the client cannot predict when a change will occur and changes are like to happen. Example: Using a WebSocket on social applications, can update your feed in real-time or also getting a notification on your post as soon as your friend reacts to that.

Also if you are including sports information in your web application, WebSockets can keep your users up to speed.

Quick Reaction: When a client needs to react quickly to a change or an update, using Websocket is the best. A good example of this is a chat application that allows multiple users to chat in real-time.

Impromptu messaging: Websocket design provides bi-directional messaging. Messages may be sent from either end of the connection at any time, and there is no native support for one message to indicate that it is related to another message. Websocket design is well suited for fire and forget messaging scenarios.

How it works?

To establish a WebSocket connection, the client sends a WebSocket handshake request, for which the server returns a WebSocket handshake response. The handshake resembles HTTP in allowing servers to handle HTTP connections as well as WebSocket connections on the same port.

Once the connection is established, communication switches to a bi-directional binary protocol which doesn’t conform to the HTTP protocol. Now, the client and server can send WebSocket data or text frames back and forth in full-duplex mode. The data is minimally framed, with a small header followed by a payload.

When not to use WebSocket?

When we know when to use WebSocket, it is also important to know when not to use it.

Following are scenarios where Websockets are not preferred:

Edge Caching: When your application benefits from caching, that is when the representation of your app changes rarely. Websocket design does not allow explicit proxies to cache messages as it prevents caching proxy from re-sending a previous WebSocket conversation. A usage of WebSocket can degrade client performance in this scenario.

Safety: Websocket does not provide any authentication, privacy or integrity, the protocol leaves these issues to the messaging layer design.

Transactional messaging: Websockets are poorly suited for transactional requirements or download and upload techniques as it does not support Request-Response messaging pattern. The messaging layer must address your transactional needs if that’s needed in your application.

How I solved: Failed to fetch http://ppa.launchpad.net/.., 403 Forbidden

Deepika Banoth — Thu, 23 Apr 2020 05:13:51 +0000

I've been using Ubuntu 16.04 vagrant machine for quite some time now. I wanted to install a package, for which I had to do sudo apt-get update before.
But when I ran this command in my machine, it failed with the following error:

Err:12 http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu xenial/main amd64 Packages
  403  Forbidden
Ign:13 http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu xenial/main Translation-en
Reading package lists... Done
W: The repository 'http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu xenial Release' does not have a Release file.
N: Data from such a repository can't be authenticated and is therefore potentially dangerous to use.
N: See apt-secure(8) manpage for repository creation and user configuration details.
E: Failed to fetch http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu/dists/xenial/main/binary-amd64/Packages  403  Forbidden
E: Some index files failed to download. They have been ignored, or old ones used instead.

It looked like there is an invalid repository which gives 403 error

So as a workaround, I thought of temporarily commenting out that in source list.
I grepped all the enabled binary sources by running this command:

grep -r --include '*.list' '^deb ' /etc/apt/sources.list /etc/apt/sources.list.d/

which gave output:

/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial main restricted
/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial-updates main restricted
/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial universe
/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial-updates universe
/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial multiverse
/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial-updates multiverse
/etc/apt/sources.list:deb http://archive.ubuntu.com/ubuntu xenial-backports main restricted universe multiverse
/etc/apt/sources.list:deb http://security.ubuntu.com/ubuntu xenial-security main restricted
/etc/apt/sources.list:deb http://security.ubuntu.com/ubuntu xenial-security universe
/etc/apt/sources.list:deb http://security.ubuntu.com/ubuntu xenial-security multiverse
/etc/apt/sources.list:deb [arch=amd64] https://download.docker.com/linux/ubuntu xenial stable
/etc/apt/sources.list.d/jonathonf-ubuntu-python-3_6-xenial.list:deb http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu xenial main
/etc/apt/sources.list.d/nodesource.list:deb https://deb.nodesource.com/node_8.x xenial main

So in my case jonathonf-ubuntu-python-3_6-xenial.list has the problem.
So I commented out the content in /etc/apt/sources.list.d/jonathonf-ubuntu-python-3_6-xenial.list, which now looks like:

# deb http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu xenial main
# deb-src http://ppa.launchpad.net/jonathonf/python-3.6/ubuntu xenial main

Now when I ran sudo apt-get update again after this fix, it worked fine for me.

If you are facing the above error, you can also use this as a workaround and if you have a better solution please let me know :)

Have a great day!

What is Continuous Integration and Continuous Delivery?

Deepika Banoth — Fri, 17 Apr 2020 05:20:56 +0000

We all follow few rules while writing code. Few of the basic rules involves indentation, syntax, maximum letters in a line, etc.,

I being a developer, I always wanna push good code. This can only be achieved by testing what you have written. At least I wanna meet my basic rules of writing code.

But is it possible to test each line of your code during a tight schedule?

There were times when my pull request was rejected for improper alignment of code. Also, there were times when I broke our Staging environment due to my code change. This is all because of lack of testing.

For example, if you are a javascript developer, you can run js lint before sending a pull request and resolve if it throws an error. What if you have changes in multiple repositories?

How will you test optimized by utilizing time? Here, Continuous Integration comes in to picture.

What is Continuous Integration?

Continuous Integration is a software development practice of testing each change done in your central repository automatically by running automated builds and tests.

From the diagram, we can see: Developer does a code change and pushes changes to his/her own repository. As soon as he/she commit changes a webhook is triggered by the version control, in my case am using Github. Now, the commit webhook will trigger a build which actually runs all your test cases. You can use any CI/CD platform to run your build, amusing JFrog Pipelines.

Now if your build fails, you can go back and do the required changes. If your build passes then you can raise a pull request and send it for review.

I believe the goal of Continous Integration is to find and address bugs as soon as possible. This improves your code quality, system quality and reduce the time it takes to validate any new updates.

What is Continuous Delivery?

Continuous Delivery follows the testing that happens in CI and push to staging/production environments continuously.

The core idea here is to deliver the code to QA or any user base so that it can be regularly reviewed. The main motivation of all this is to improve your software and of course to ship good code.

I hope you find this post helpful 🙂

Scheduled triggers using JFrog Pipelines

Deepika Banoth — Wed, 15 Apr 2020 10:02:18 +0000

Jfrog Pipelines support automatic triggers through webhooks, REST API based triggers, as well as manual triggers through the UI.
Jfrog Pipelines also provides you the ability to schedule a Pipeline to be triggered at specific date/times, or at a recurring interval.

You can use the cronTrigger resource of JFrog Pipelines to achieve the functionality scheduled triggers in your workflow.

Before starting I would like to quickly tell you about JFrog Pipelines key concepts which would help you understand this better.

Concept	Description
Pipeline	It is a collection of interconnected serial or parallel steps required to achieve an outcome
Steps	Steps are the executable units of your pipelines that can execute any DevOps activity
Integrations	Integrations contain credentials to third-part tools/services such as AWS, slack, Github, etc.,
Resources	Resources contain information required to execute steps
Run	Run is an instance of pipeline execution

CronTrigger Resource

cronTrigger resource provides cron-like functionality. It is used to trigger a build in a cron-like manner.
You can define the resource in your yaml config file as:

- name: cron                 #friendly name to remember
  type: CronTrigger
  configuration: 
    interval: "*/2 * * * *"  #follows the standard Cron format

This resource can be used as an inputResource to a step in pipeline as follows:

steps:          
      - name: bash_1
        type: Bash
        configuration:
          inputResources:
            - name: github
            - name: cron        #created CronTrigger resource name
        execution:
          onExecute:
            - echo "executing bash step."

If the CronTrigger typed resource is given as Input to a step then it gets triggered at the recurring interval or at a specific date as depends on what you configure in interval.
A new run will be created every time the step is triggered.
In my example, this bash_1 step will be triggered by cron resource in every 2 minutes as shown in the below screenshot:

You can also schedule to trigger this on a particular day by just updating the interval in the resource definition as per cron syntax.

Hope this helps. :)

Vue watchers vs computed properties

Deepika Banoth — Fri, 03 Apr 2020 10:03:39 +0000

From the past few days, I have been spending most of my time in learning and understanding how Vue and its reactivity works.
Today I would like to share my learnings on when to use watchers and computed properties.
To be noted, I am still at beginner level :)

When to use Computed properties

Computed Properties can react to changes in multiple properties, so you can use it when you have a variable in your template, that's built from one or more data properties. A simple example would be creating fullName from the list of firstName and lastName:
```
    computed: {
      fullName() {
        return `${this.firstName} ${this.lastName}`
      }
    }
```
Computed Properties are very useful for composing new data from existing sources

The output of a computed property is cached, this means that if something independent of the computed property changes and the UI is re-rendered, the cached result will be returned and the property will not be re-calculated, sparing us an expensive operation
For example, consider two counters, in which computedCounter will be updated from computed button and methodCounter will be updated from method button

    data: function() {
      return {
        computedCounter: 0,
        methodCounter: 0
      };
    },
    computed: {
      printMsgComputed: function() { 
         console.log(“printed from computed:”,     
         this.computedCounter);
      } 
    },
    methods: {
      printMsgMethod: function() {
         console.log(“printed from method:”, 
          this.methodCounter);
      }
    },

HTML:

   <div>
      <button @click=”computedCounter++”>computed button</button>
      <p>{{ computedCounter }}</p> <br/>
      <button @click=”methodCounter++”>method button</button>   
      <p>{{ methodCounter }}</p> <br/>

      {{ printMsgMethod() }}
      {{ printMsgComputed }}
  </div>

When the above code is executed and when you click on computed button both printMsgMethod and printMsgComputed will run.
But when you click on method button you can see that only printMsgMethod running. You

Computed properties creates new reactive properties, so you can use it when you want to reduce a nested property name to a more readable and easy to use one, yet update it when the original property changes
You can also use computed properties when you need to listen to changes of more than one data property

When to use Watchers

Watchers are useful for cases when you want to perform an action in response to a data property change
Also Watchers are most useful when you want to perform asynchronous or expensive operations in response to changing data
You can also use watchers when you only need to listen to one specific property

Also Computed properties are only executed when they are needed to be used whereas Watchers are executed whenever a property is changed.

Correct me if I am wrong or missed something.

Managing integration of CI/CD server to DevOps Environment

Deepika Banoth — Fri, 20 Mar 2020 09:04:44 +0000

We all know that CI or CD server needs to be tightly connected or integrated across your DevOps environment.

But the problem in most of the CI servers today, is that you have to configure for each job every time.
For example, if you are trying to deploy to Kubernetes using Jenkins, you have to configure this at a Job level and you can only verify this by actually running the build.
If you need this KubeConfig in few other jobs the only way in here is that you add the same config file in all other required jobs.
Now imagine, you need to change something in the config file, now you have to go to all other places and change them, which is not effective.
This stands the same for deploying to Google Cloud or AWS or any other cloud provider which might also require some plugin to make it work.

So just to tackle this problem, JFrog Pipelines extracted these out into a central system, created a pointer for you which you can use it in your steps where our platform gonna inject them during run time and we call these as Integrations.

Integrations are used to connect your Pipelines CI or CD workflows to third party platforms or services and manage secrets like keys, tokens, passwords that are needed for Steps in a Pipeline to interact with the source.
All credential information is encrypted and maintained separately from the pipeline definition, and held in a secure storage.

The biggest advantages of our design for integrations are:

Integrations are created in the UI and used with friendly names in your YAML config. This means you do not have to touch your automation scripts when an integration is updated.
Integrations are securely stored in a Vault store and encrypted at rest and in-flight.
Integrations values are not revealed in logs unless you choose to print them out as part of your workflow. You can scope each integration to allow or deny access for Pipeline Sources

Let me show an example of adding an integration and using it in one of your step.

Add New Integration

To add new integration, Go to Pipelines->Integrations tab and click on Add an Integration,
You can give some friendly name and select the type of integration which you want to create.

The available integration types for Jfrog Pipelines are:
Airbrake, Artifactory, AWS Keys, Azure Keys, Bitbucket, Digital Ocean, Distribution, Docker Registry, External Webhook, File Server, Generic, Github Enterprise , Github, Gitlab, Google Cloud, Internal Webhook Integration, Jira, Kubernetes, Newrelic, PEM Key, Slack, SMTP Credentials, SSH Key

Once you added all the required fields:

You can also set which Pipeline sources can use this integration:

After creating, you can add the integration directly to a step:

   steps:          
      - name: sample_bash
        type: Bash
        configuration:
          integrations:
            - name: myArtifactory
        execution:
          onExecute:
            - echo "executing bash step."
            - echo $int_myArtifactory_url

when you do that, a set of environment variables is automatically made available.

You can also send notifications using utility function: send_notification whenever your step succeeds or fails due to some reason using Notification integrations: Airbrake, Slack, Jira, NewRelic, Outgoing webhook, SmtpCreds(email)

   steps:
      - name: sample_bash
        type: Bash
        configuration:
          integrations:
            - name: myArtifactory
            - name: mySlack
            - name: myJira
        execution:
          onExecute: 
            - echo "executing bash step."
          onSuccess:
            - send_notification mySlack
          onFailure:
            - send_notification myJira --project-id myProjectOnJira --type Bug --summary "sample_bash step: ${step_id} failed"

Hope this helps! :)

How to: use jsonb_set function in PostgreSQL

Deepika Banoth — Fri, 21 Feb 2020 06:35:02 +0000

Definition:

jsonb_set(target jsonb, path text[], new_value jsonb, [create_missing boolean])
Returns target with the section designated by path replaced by new_value, or with new_value added if create_missing is true (default is true) and the item designated by path does not exist. As with the path oriented operators, negative integers that appear in path count from the end of JSON arrays.

Let's take the below data set as an example:

[
  {
     "id": 1,
     "type": "Place",
     "details":'{ "name": "Taj Mahal", "url": "images/0001.jpg"}'
  },
  {
     "id": 2,
     "type": "Place",
     "details":'{ "name": "Eiffel Tower", "url": "images/0002.jpg"}'
  },
  {
     "id": 3,
     "type": "Food",
     "details":'{ "name": "Biryani", "url": "images/0003.jpg"}'
  },
  {
     "id": 4,
     "type": "Food",
     "details":'{ "name": "Pizza", "url": "images/0004.jpg"}'
  }
]

The model Example of the object in postgresql is something like this:

{ 
   "id" smallint,
   "type" character varying(50),
   "details" text
}

Now, here are the following queries you can use in postgres to parse, update the object:

1. How to parse JSON value of text column

Let's fetch object of name Biryani from the above data set

SELECT * FROM "Example" WHERE "details"::json->>'name'='Biryani';

The above query will return:

-[ RECORD 1 ]---------------+---------------------------------------------
id                          | 3
type                        | Food
details                     | { "name": "Biryani", "url": "images/0003.jpg"}

2. How to update JSON value of text column

Here is the query to update url of Eiffel Tower object:

UPDATE "Example" SET "details"=jsonb_set("details"::jsonb, '{url}', '"images/0005.jpg"'
WHERE "details"::json->>'name'='Eiffel Tower';

now the updated object will look like:

-[ RECORD 1 ]---------------+---------------------------------------------
id                          | 2
type                        | Place
details                     | { "name": "Eiffel Tower", "url": "images/0005.jpg"}

How to fix: "locale.Error: unsupported locale setting" on pip install

Deepika Banoth — Tue, 21 Jan 2020 09:49:22 +0000

If you see the following error while installing pip:

Traceback (most recent call last):
     File "/usr/bin/pip", line 11, in <module>
       sys.exit(main())
     File "/usr/lib/python2.7/dist-packages/pip/__init__.py", line 215, in main
       locale.setlocale(locale.LC_ALL, '')
     File "/usr/lib/python2.7/locale.py", line 581, in setlocale
       return _setlocale(category, locale)
   locale.Error: unsupported locale setting

this means the environment variable LC_ALL is missing or invalid somehow.

FIX :

run the following command:

export LC_ALL=C

and retry installing again.

What is LC_ALL?

LC_ALL is the environment variable that overrides the value of the LANG and the values of any other LC_* environment variables.

In a script, if you want to force a specific setting, as you don't know what settings the user has forced, your safest and generally only option is to force LC_ALL.

The C locale is for computers. In the C locale, characters are single bytes, the charset is ASCII, the sorting order is based on the byte values, the language is usually US English.
You generally run a command with LC_ALL=C to avoid the user's settings to interfere with your script. For example, if you want [a-z] to match the 26 ASCII characters from a to z, you have to set LC_ALL=C.

Hope this helps! :)

What happens when I type a URL in browser

Deepika Banoth — Thu, 19 Dec 2019 07:04:38 +0000

Ever wondered what actually happens when you type a URL in the browser?

I think this is a very common query that lingers around in our mind every time we type a URL in the browser.

So today am gonna briefly discuss what happens when you type a URL in the browser.

You enter a URL into the browser. It all starts here.

Basically, whenever we want to connect to a particular server, for example, let's consider google.com. Here we actually want to reach out to a server where google web services are hosted. As an example, I have given one such server, as google has around one million servers in various locations.

The browser looks up the IP address for the domain name. DNS server which I would call a resolver does look up to find the IP address of the server.

DNS lookup proceeds by:

First checking Browser cache
If the browser doesn’t contain the record in its cache. It makes a system call to the underlying operating system to fetch the record
If that also fails, then the search continues to your router which has its own cache
If everything fails, then the search moves on to ISP. It first tries in its cache, if not found then ISP’s DNS recursive search comes into picture

So the domain name which you have entered gets converted into the DNS number.

After which the browser initiates a TCP connection with the server and sends an HTTP GET request. Now the webserver passes on the request to the proper request handler which will return an HTML response in our case.

This HTML data stream response is then sent back to the browser. Now the browser receives the HTTP response and then the browser displays the HTML content. In our case its the google web page.

Rendering of HTML content is done in phases. It first gets HTML structure and then sends multiple GET requests to fetch links and other stuff. And there is a lot more after this. And yeah this is just an outline on what happens when you type a URL.

Hope this helps 🙂

Video on what happens when you type URL in browser. Click to watch

How to Install Node.js using NVM on Linux

Deepika Banoth — Mon, 09 Dec 2019 10:54:15 +0000

NVM aka Node Version Manager is a simple bash script to manage active Node.js versions. Using NVM you can easily install Node.js and also you can install a specific Node.js version or multiple Node.js versions on the same system.

STEP-1: Install NVM

To install or update NVM, you need to run the install script. Use the following command to install NVM on your Linux machine.

curl https://raw.githubusercontent.com/creationix/nvm/master/install.sh | bash

Reload system environment using this command:

source ~/.bashrc

It will set the required environment variables to use nvm on the system.

Verify NVM
Run the following command to check if the nvm is installed:

command -v nvm

If it's installed correctly, you will see

nvm

as message printed.

STEP-2 Find Node.js version

As now NVM is installed in your system, find out the available Node.js version to install. You can run the following command to find out:

nvm ls-remote

A long list of available Node.js versions is printed:

       . . .
       v10.12.0
       v10.13.0   (LTS: Dubnium)
       v10.14.0   (LTS: Dubnium)
       . . .
       . . .
       v10.17.0   (Latest LTS: Dubnium)
        v11.0.0
       . . .
       . . .
       v12.12.0
       v12.13.0   (LTS: Erbium)
       v12.13.1   (Latest LTS: Erbium)
        v13.0.0
        v13.0.1
        v13.1.0
        v13.2.0
        v13.3.0

STEP-3 Node.js installation

Now install the Node.js version you need to use.

nvm install v12.13.1

You can install multiple versions as well, just specify the version you want to install: nvm install $version.

STEP-4 Set default version

If you have installed multiple Node.js versions, then select a specific version as default version of Node.js used by your machine.
Run the following command to get the list of currently installed Node.js versions

 nvm list

you will see similar output:


->     v10.16.3
       v12.13.1
         system
default -> v12.13.1
node -> stable (-> v12.13.1) (default)
stable -> 12.13 (-> v12.13.1) (default)
iojs -> N/A (default)
unstable -> N/A (default)
lts/* -> lts/erbium (-> v12.13.1)
lts/argon -> v4.9.1 (-> N/A)
lts/boron -> v6.17.1 (-> N/A)
lts/carbon -> v8.16.2 (-> N/A)
lts/dubnium -> v10.17.0 (-> N/A)
lts/erbium -> v12.13.1

You can see that v12.13.1 is set as the default version. You can use the following command to change default version:

nvm use v10.16.3

Now, verify the current version of Node.js

  node --version

v10.16.3

If you want to uninstall a specific version of Node.js, you can use the following command:

nvm uninstall v12.13.1

I hope this tutorial helps :)

Creating your first web app with Node.js

Deepika Banoth — Mon, 02 Dec 2019 03:41:26 +0000

Hello everyone! I hope you are all doing great. 🙂

Today we will create a very simple web application using Node.

Let's get started! 🙂

"Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live." – Martin Golding

This is one of my favorite quotes. And actually it is not a bad idea to write a clean code. If you are looking back at your code after some months or years, at least you should be able to understand what you wrote.

So, lets first create a very simple file structure which will help in managing it easily. We will be putting most of the code of our Node application into the server.js file.

However, for larger applications, server.js should be broken down further to separate duties.

Installing Modules

The package.json holds configuration of our application. Node’s package manager (npm) will use this to install and dependencies or modules that we are going to use.

Now open your terminal, go to your project and run npm install, npm will look at this file package.json and install all dependencies.

Node Configuration

Our main file server.js will configure the app for Express, and listening on a port.

Start Your Application

Now that we have package.json and server.js started up, we can start up our server and see whats going on. Just go to your project folder in your terminal and type command node server.js. Now you have a server listening on a port 3000. Going to http://localhost:3000, you should be seeing something like this:

You can also add a html which has code of our main view

and use the path in the server.js.

Note: The path you mention here must be absolute.

I hope this post helps 🙂

Setting up Github Enterprise server on AWS

Deepika Banoth — Wed, 27 Nov 2019 05:06:34 +0000

Hello everyone! I hope you all are doing great. Today, I am going to show you step by step on how you can set up a GitHub enterprise server on AWS.

1: GET THE GITHUB ENTERPRISE AMI

To Install Github Enterprise on AWS, you must launch an EC2 instance first.

To launch any instance on EC2, you need an AMI. Well, what is an AMI?

An AMI (Amazon Machine Image) is a special type of virtual appliance that provides all the required information to launch an instance on Elastic Compute Cloud (EC2).

Now, follow these steps to get the Github Enterprise AMI:

Now click on Get the latest release of Github Enterprise under Download the Appliance section.

Now, select Amazon Web Services as the platform under Github in the Cloud section. And then under Select your Amazon region, select a region where you want to set up Github Enterprise. I am selecting us-east-2. As soon as you select the region, AMI ID will be displayed in the same section.

Take note of the AMI ID, as it is required to launch instance.

2. CREATE EC2 INSTANCE

As now we have the AMI ID, let's create the EC2 instance. For that, at first login to AWS console. Go to EC2 service dashboard and click on Launch Instance. Make sure that you create an instance in the same region where you have selected while getting AMI ID of Github Enterprise.

As soon as you click on Launch Instance, it will ask you to choose an AMI.

Now, go to Community AMIs section to search for the AMI ID which you got in first step:

Select the AMI and continue.

Now you need to choose the Instance Type. Github Enterprise is supported on the following EC2 instance types:


C3	C4	M3	M4	R3	R4	X1
c3.2xlarge	c4.2xlarge	m3.xlarge	m4.xlarge	r3.large	r4.large	x1.16xlarge
c3.4xlarge	c4.4xlarge	m3.2xlarge	m4.2xlarge	r3.xlarge	r4.xlarge	x1.32xlarge
c3.8xlarge	c4.8xlarge		m4.4xlarge	r3.2xlarge	r4.2xlarge
			m4.10xlarge	r3.4xlarge	r4.4xlarge
			m4.16xlarge	r3.8xlarge	r4.8xlarge
					r4.16xlarge

Select one of the instance type based on your seat count. And click on Next: Configure Instance Details

Now, if you want to customize instance configuration details then you may change it here:

As I don’t want any changes, I am skipping this and moving forward by clicking on Next: Add Storage.

Now, Github Enterprise needs a separate EBS volume of at least 10 GiB for git data and user data. So, click on Add New Volume and create an EBS volume of size > 10 GiB and move forward to Next: Add tags.

Now, you can create a Tag for this instance by adding name and value. Adding a tag helps you in identifying the instance in the dashboard.

Move on to Next: Configure Security Group and add a security group for the instance. Basically a security group is a set of firewall rules that control the traffic for your instance. While creating the security group add rules for each port in the table below:

Port	Service	Description
22	SSH	Git over SSH access. Clone, fetch and push operations to public/private repositories supported.
25	SMTP	SMTP with encryption (STARTTLS) support.
80	HTTP	Web application access. All requests are redirected to the HTTPS port when SSL is enabled.
122	SSH	Instance shell access. The default SSH port (22) is dedicated to application git+ssh network traffic.
161/UDP	SNMP	Required for network monitoring protocol operation.
443	HTTPS	Web application and Git over HTTPS access.
1194/UDP	VPN	Secure replication network tunnel in High Availability configuration.
8080	HTTP	Plain-text web-based Management Console. Not required unless SSL is disabled manually
8443	HTTPS	Secure web-based Management Console. Required for basic installation and configuration.
9418	Git	Simple Git protocol port. Clone and fetch operations to public repositories only. Unencrypted network communication.

Add rules for each of the port mentioned above in the table.

Now, Click on Review and Launch button. Make sure, everything is correctly configured. And click on Launch when you are ok with it.

Create key-value pair which can be used to ssh into that machine.

Now click on View Instances. And copy the Public DNS of the newly created GHE instance and open it in a new tab of your web browser. It is located at the bottom right.

Once you put the public DNS in your browser you will see:

This is because, Github Enterprise have a self-signed SSL certificate, because of which you might be prompted on the next screen with a warning. We can get past that screen based on which browser you are using. If you want to double-check, you can verify by ssh into the machine and following the steps as written on your screen. Now click on Continue to setup.

If you are on safari, you will get an alert box asking to continue or not. You can click on continue.

If you are on chrome, this will redirect you to a page, where you can click Advanced under it click on Proceed to ec2-13-58-244-179.us-east-2.compute.amazonaws.com.

After that, you will be asked to upload your license files. If you don’t have one, you can get them from Github Enterprise Download page.

Click on Download your license and upload it here on your machine.

You have to create a new password for authentication. And click on Finish Installation once you are done uploading and creating a password.

Now you will be asked to choose the installation type. I will be choosing New Install.

You will be redirect to Admin settings page, where you can configure the GHE instance. Click on Save Settings once you are done.

Now it will configure the settings to your instance, it might take some time. Once all the checks are done you can click on Visit your Instance.

And that’s it Github Enterprise is installed on your machine, you can create an admin account and later you can create or export projects.

I hope you find this tutorial helpful.