
## Table of Contents

1. [Introduction](#introduction)
2. [Requirements](#requirements)
3. [Create Next.js App](#create-nextjs-app)
4. [Create Dockerfile](#create-dockerfile)
5. [Build and Run Docker](#build-and-run-docker)
6. [Test](#test)
7. [Conclusion](#conclusion)

## Introduction

This blog demonstrates a quick start guide for trying Docker with Next.js.

## Requirements

Before we get started, you'll need to download Docker and Node.js so that we can run `docker`, `npm`, or `node` from the local environment.

- Install [Docker](https://www.docker.com/)
- Install [Node.js](https://nodejs.org/)

## Create Next.js App

Here, we'll follow the Next.js documentation to create a default Next.js web app. First, let's run the command below based on the instructions.

```Javascript
npx create-next-app@latest
```

Follow the command's instructions and it should create a Next.js app. Type `http://localhost:3000` in your browser, and you'll see the default Next.js website.

## Create Dockerfile

Create a file called `Dockerfile` and add the following content. This will use the Alpine Docker image, copy all the current directory content, run `yarn install` and `yarn run build`, and expose port 3000.

```
FROM node:16-alpine
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
COPY . .
RUN yarn install
RUN yarn run build
EXPOSE 3000
CMD ["yarn", "run", "start"]
```

## Build and Run Docker

Run the command below in the same directory. This will create a Docker image.

```
docker build -t my-first-docker-app .
```

Run this command to check the image we just created.

```
docker images
```

Now, run this command to execute the Docker image in a new container with port 9000. The `-p` flag is for `--publish`, which publishes the container's port to the host.

```
docker run -p 9000:3000 {the image id}
```

## Test

You can either type `http://localhost:9000` in your browser or run the command below to verify that Next.js is up and running.

```
curl http://localhost:9000
```

## Conclusion

The above is a simple set of steps to create a Next.js app with Docker. Hopefully you found this blog helpful, and feel free to reach out if you want to see more content like this.


A simple tutorial about how to get started with Docker by using Next.js as a web server.

Getting Started with Docker and Next.js


## Table of Contents

1. [Introduction](#introduction)
2. [Requirements](#requirements)
3. [Create Node.js App](#create-nodejs-app)
4. [Create Dockerfile](#create-dockerfile)
5. [Build and Run Docker](#build-and-run-docker)
6. [Test](#test)
7. [Useful Docker Commands](#useful-docker-commands)
8. [Conclusion](#conclusion)

## Introduction

This blog demonstrates a quick start guide for trying Docker with Node.js.

## Requirements

Before we get started, you'll need to download Docker and Node.js so that we can run `docker`, `npm`, or `node` from the local environment.

- Install [Docker](https://www.docker.com/)
- Install [Node.js](https://nodejs.org/)

## Create Node.js App

Here, we'll create a very simple Node.js web app. First, let's run the commands below.

```Javascript
npm init -y
npm install --save express
nano server.js
```

These commands will first initialize an npm repo in the local directory, install `express` as the web server, and create a new file called `server.js`.

Inside `server.js`, we'll put the following content.

```Javascript
const express = require('express')
const app = express()

app.get('/', (req, res) => {
    res.send('hello world!')
})

app.listen(4455, () => {
    console.log('server is up on 4455')
});
```

This code will start a web server on port `4455` and return the message `hello world!`.

If you type `http://localhost:4455` in your browser, you should see the message `hello world!`.

## Create Dockerfile

Docker can build images, and later you can load and run those images. The `Dockerfile` contains the instructions for how to build the image.

Create a file called `Dockerfile` and add the following content. This will use the Alpine Docker image, copy all the current directory content, run `npm install`, and expose port `4455`.

```
FROM node:8-alpine
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
COPY . .
RUN npm install
EXPOSE 4455
CMD ["node", "server.js"]
```

## Build and Run Docker

The Node.js code is ready and the Dockerfile is ready too. Now we can use the Dockerfile to build an image and run it in our local environment.

Run the command below in the same directory as the Node.js app. This will create a Docker image.

```
docker build -t my-first-docker-app .
```

If you run this command, you should be able to see the image you just created.

```
docker images
```

Now, run this command to execute the Docker image in a new container with port 4455. The `-p` flag is for `--publish`, which publishes the container's port to the host.

```
docker run -p 4455:4455 {the image id}
```

## Test

Run this command on your local environment. We should see `hello world!` from the Node.js app.

```
curl http://localhost:4455
```

## Useful Docker Commands

Here are a few other commands that might be useful when working with Docker.

### List All Docker Images

```
docker images
```

### List All Containers

```
docker container ls
```

### Stop a Container

If you have a website running in a Docker container, once you stop the container you won't be able to access it.

```
docker stop {container ID}
```

### Find All Containers Including Stopped Ones

```
docker container ls --all
```

### Delete a Container

```
docker container rm {container id}
```

### Delete All Containers

```
docker rm $(docker ps -aq)
```

### Delete All Images

```
docker rmi $(docker images -q)
```

## Conclusion

The above is a simple set of steps to create a Node.js app, including creating a Docker image based on the Node.js image, running the Docker image in a container, and accessing it from outside the environment with the port opened. Hopefully you found this blog helpful, and feel free to reach out if you want to see more content like this.


A simple tutorial about how to get started with Docker by using Node.js as a web server.

Getting Started with Docker and Node.js


## Table of Contents

1. [Introduction](#introduction)
2. [Setup EC2 Ubuntu](#setup-ec2-ubuntu)
3. [Install Docker and Docker Compose](#install-docker-and-docker-compose)
4. [Clone the Sentry Self-Hosted Repo](#clone-the-sentry-self-hosted-repo)
5. [Install Sentry and Create a New User](#install-sentry-and-create-a-new-user)
6. [Run Docker Compose](#run-docker-compose)
7. [Conclusion](#conclusion)

## Introduction

This blog shows how to self-host Sentry.io on an AWS EC2 instance.

Sentry.io provides a self-hosted solution and hosts the source code
[here](https://github.com/getsentry/onpremise). Based on the Sentry
self-host requirements, you'll need to meet the following specifications.
These requirements will probably change when a new version comes out, so
double-check the requirements before setting up the instance.

- Docker 19.03.6+

- Compose 1.28.0+

- 4 CPU Cores

- 8 GB RAM

- 20 GB Free Disk Space

## Setup EC2 Ubuntu

### Launch AWS EC2 Instance

### Choose Ubuntu Server 20.04, Free Tier Eligible

### Choose t2.medium

The requirement is 4 CPU cores, but it looks like a minimum of 2 CPUs works
fine, so I chose t2.medium here.

### Configure Instance Details

This blog does not cover setting up AWS VPC or subnets. Most of the settings
here can be left as default, as long as the VPC has public access.

### Add Storage

For storage, set the size to 25 GB.

### Configure Security Group

Depending on how you want to host Sentry, this could vary. At a minimum, make
sure ingress ports 80 and 22 are open — one for access from the internet and
another for SSH into the instance.

### Finish Creating the Instance

After finishing the EC2 instance creation for Ubuntu, SSH into the instance.
After connecting, we'll perform the following tasks to install Docker.

## Install Docker and Docker Compose

### Setup the Repository

```
sudo apt-get update
sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release
```

### Add Docker's Official GPG Key

```
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

echo \
  "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

### Install Docker Engine

```
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io
```

### Install Docker Compose on Linux

```
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
```

### Apply Executable Permissions to the Binary

```
sudo chmod +x /usr/local/bin/docker-compose
```

### Reboot Ubuntu

## Clone the Sentry Self-Hosted Repo

```
git clone https://github.com/getsentry/onpremise.git
```

## Install Sentry and Create a New User

During the installation process, you will be asked to create a new account.
Enter the email and password to create a new account. You'll use the email and
password to log in later.

```
cd onpremise/
sudo ./install.sh
```

## Run Docker Compose

This docker-compose command might take some time to finish everything, but
once it completes, you should be able to access Sentry via the browser using
the instance's IP address.

```
sudo docker-compose up -d
```

## Conclusion

If everything works, when you navigate to the instance's IP address in your
browser, you should see the Sentry.io login page. Enter the email and password
you created earlier to log in.

References

- Install Docker Engine on Ubuntu

- Install Docker Compose

- Self-Hosted Sentry nightly


This blog shows how to self-host Sentry.io on an AWS EC2 instance.

How to Self-Host Sentry.io on AWS EC2


## Table of Contents

- [Introduction](#introduction)
- [So I'm Trying to Use Docker on My Mac](#so-im-trying-to-use-docker-on-my-mac)
- [Boom! Docker!!](#boom-docker)
- [Now, How Do I Host My Content with Nginx](#now-how-do-i-host-my-content-with-nginx)
- [Install SQL Server on Mac with Docker](#install-sql-server-on-mac-with-docker)
- [Conclusion](#conclusion)
- [Reference](#reference)

## Introduction

Docker supports both Windows and Mac as development machines. I have used VirtualBox from Sun Microsystems, VMware which is also a leader in system virtualization, and Microsoft Virtual PC. There are many more different kinds of virtualization software, but these are a few I have used and I think they're the main ones. Now, when I used these, they were all the same — I had to download them, then install the OS I wanted to use, then install the list of middleware I wanted for that system. It seemed reasonable to me at that moment, but if there's something faster and more reliable, would you use it? That sounds like **Docker**.

## So I'm Trying to Use Docker on My Mac

Then, what! You can use SQL Server on Mac!

### But Before That, Here's What I Did First

1. [Install Docker](https://docs.docker.com/docker-for-mac/install/#download-docker-for-mac) - Get the Community Stable Channel Version for Mac.

Move Docker to the Applications folder and run it.

When Docker is done, you'll see "Docker is now up and running."
Now you can use your favorite command line terminal to run commands.

![](http://res.cloudinary.com/dmwrakaup/image/upload/v1508363461/u7qemwogkdp5ixlj9z87.png)

```
// get current docker's information
docker info
// get docker's version
docker version
// get current images store
docker images
// show running container
docker ps -a
```

Those commands are the basic commands. You will learn the Docker version and information from them. So, when you try something a little more advanced like the following — creating an **Nginx** HTTP web server — Nginx is an open-source HTTP server built for performance. When you type the following command in the terminal:

```
docker run -d -p 80:80 --name my-server nginx
```

With the above command, Docker will get the Nginx image from Docker Hub if your local machine doesn't have this Nginx image. Also, when you type `localhost`, you will see the Nginx sample website running.

```
// stop my Nginx web server
docker stop my-server

// start my Nginx web server
docker start my-server

// remove my Nginx web server
docker rm my-server
```

![](https://d1p0mp3f1fx0hz.cloudfront.net/_58yota05n.png)

## Boom! Docker!!

That's a surprise to me. If you compare it to using VirtualBox, it's just so easy and simple. Also, you don't need to install Linux — it just works, because Nginx currently supports Ubuntu, FreeBSD, CentOS, Debian, and other Linux distributions. That's cool.

## Now, How Do I Host My Content with Nginx

I know I can run Nginx on my Mac without having to install Linux, using my Mac's localhost on port 80. Now, I want to develop something using this Nginx dev web server. First, let's prepare the following HTML:

```



      Docker Nginx



                hello!
                My first Nginx Web Server




```

The next step is to tell Docker where your source code is. Assume your HTML is at the following location: `{My Folder which has html}`

```
docker run -d -p 80:80 -v {MyFolder path which contains html}:/usr/share/nginx/html:ro -d nginx
```

![](https://d1p0mp3f1fx0hz.cloudfront.net/_hjfp3ued6.png)

Cool, I think I like this simple easy setup.

## Install SQL Server on Mac with Docker

You can use this command to install SQL Server 2017 on your Mac:

```
docker run -e 'ACCEPT_EULA=Y' -e 'MSSQL_SA_PASSWORD=' -p 1401:1433 --name sql1 -d microsoft/mssql-server-linux:2017-latest
```

Also, you can install the following npm package **sql-cli** for querying:

```
npm install -g sql-cli
// or run as administrator
sudo npm install -g sql-cli
```

In addition, Docker has a UI tool to manage settings called **Kitematic**.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_p9rxyenz3.png)

## Conclusion

Docker brings a new approach to development — it is fast. It works very well if you want to build a web server like Nginx for development but don't want to spend lots of time creating a Linux environment or setting up an Nginx web server. It works great if you want to set up a MongoDB dev environment but don't want to visit the website to choose the version, set up the Mongo service, and configure a basic user. If you use Docker, it handles the setup for you and supports both the command line and a UI interface with Kitematic. In addition, you can use Docker on Mac, Windows, and Linux. I'm very impressed with Docker — it'll definitely improve developer productivity.

Although Docker is fast and powerful, like any other tool it's not perfect and can't support every single scenario. What we need to know is that Docker images support Linux, so if any middleware can be built for Linux, Docker can support it. That's why when Microsoft added SQL Server 2017 support on Linux, you could use the container on Docker — but you can't use SQL Server 2015 or lower versions. You also can't use IIS on Docker, because IIS on Linux is not supported at this time.

## Reference

- [Docker Hub](https://hub.docker.com/)
- [Docker Hub - Nginx](https://hub.docker.com/_/nginx/)
- [Download Docker - Mac](https://docs.docker.com/docker-for-mac/install/#download-docker-for-mac)
- [What's Docker!](https://www.docker.com/what-docker)
- [Run the SQL Server 2017 container image with Docker](https://docs.microsoft.com/en-us/sql/linux/quickstart-install-connect-docker)
- [Configure SQL Server 2017 container images on Docker](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-configure-docker)
- [SQL Server Running on a Mac?!](https://medium.com/@reverentgeek/sql-server-running-on-a-mac-3efafda48e26)
- [Production Quality MongoDB Setup with Docker](https://medium.com/@cramirez92/build-a-nodejs-cinema-microservice-and-deploying-it-with-docker-part-1-7e28e25bfa8b)


This blog shows how to set up Docker with Nginx and SQL Server on Mac.

Docker

Getting Started with Docker and Next.js

Getting Started with Docker and Node.js

How to Self-Host Sentry.io on AWS EC2

Setup Nginx and SQL Server with Docker