DEV Community: Guillermo Fernandez

Teamcity + AWS

Guillermo Fernandez — Fri, 02 Jul 2021 14:18:15 +0000

In this article we will explain how to create an ec2 ubuntu instance with the Teamcity server installed.

To begin with in this case we will create an instance from an Ubuntu 20.0 image. However, you can take a look at other alternatives that Amazon provides for us here: here.

When we are creating this instance it's important to save the pem file, so that you can access the machine through ssh.

After we have created the instance we will go to security and use the Public IPv4 DNS, in order to create a CNAME record on your domain to access that machine.

Access to the machine

> ssh -i "<file_name>.pem" ubuntu@ec2-ip-address.sa-east-1.compute.amazonaws.com

Install java 8 to install teamcity

> sudo apt-get update
> sudo apt-get install openjdk-8-jdk

Check the java version

> java -version

Download the Teamcity Server, in our case we downloaded the latest version: 2020-2

> sudo wget https://download-cf.jetbrains.com/teamcity/TeamCity-<version>.tar.gz

> tar xfz TeamCity-<version>.tar.gz

> sudo useradd teamcity
> sudo chown -R teamcity:teamcity TeamCity

To change the server port, in the <TeamCityHome>/conf/server.xml file, change the port number in the not commented XML node (here the port number is 8111):

Now if you browse the IP address of your server using port 8111 you should see the TeamCity web interface.

Before creating the projects we need to create at least one build agent.

> cd Teamcity/buildAgent/build
> sudo sh install.sh localhost

Finally we need to run our TeamCity Server with the following command line from: <TeamCityHome>/bin .

> sudo sh runAll.sh start

We strongly recommend that you use docker instead of installing everything locally on this server, so that you can dockerize all your applications.

You can find more information about how to Install Docker Engine on Ubuntu, here: (https://docs.docker.com/engine/install/ubuntu/)

Moreover, in my previous post you can read about Dockerizing an angular app.
On this link: (https://dev.to/ollita7/dockerizing-an-angular-app-3nef)

Dockerizing an angular app

Guillermo Fernandez — Thu, 03 Jun 2021 13:55:38 +0000

In this article I will show you how to dockerize an angular application using nginx server. If you would like more information about the nginx server you can find it here: https://www.nginx.com/

To get started we create a dockerfile with two stages:

Stage 1
Installing and building the angular application:

Copy the angular code from a local machine to a docker machine.
Copy the packages.json to install dependencies.
Install the angular-cli and npm dependencies.
Build an angular application.

For this stage we use a node machine image from the dockerhub https://hub.docker.com/_/node

Stage 2

Copy the angular dist folder from the previous docker machine named build on to the nginx location folder.
Then we use the default cmd that starts the nginx server.

For this stage we will use a node machine from the dockerhub https://hub.docker.com/_/nginx

FROM node:12.7-alpine AS build
WORKDIR /app
COPY / ./
COPY package*.json ./

RUN npm install -g @angular/cli@10.0.4 && \
    npm install && \
    ng build
COPY . .

STAGE 2: Run

FROM nginx:1.17.1-alpine
WORKDIR /app
COPY --from=build /app/dist/ui /usr/share/nginx/html

Once that is done, we will create the Dockerfile, and build the image to run it.

> docker build -t <image_name> -f Dockerfile .

Now we can verify if the image is created by running the following command.

> docker images

Now that we have created the image in order to run it we have two options:.
1) Run it using the docker command line or 2) run it using the docker-compose.
If we decide to run it using the docker-compose we have to create a docker-compose.yml file like this:

version: '3'
services:
    server:
        image: <image_name>
        ports:
            - "80:80"
        tty: true
        expose:
            - "80" 
        stdin_open: true
        environment:
            - MODE=dev
        command: <command to run>

If we want to run a command when we run the image we can specify on command.
In addition to that, we can run the image without the docker-compose by using a command line.

docker run -d -p 80:80 <image_name> command

Hope you liked and also helps you in case you have to dockerize an angular app.

Why CI/CD is important?

Guillermo Fernandez — Mon, 03 May 2021 14:03:24 +0000

According to github recent report nearly 60% of survey respondents said their organizations deploy multiple times a day, once a day, or once every few days, which perhaps reflects the large number of responses from smaller (and thus presumably more nimble) companies. Just 11% said they deploy once a month and only 8% said every few months.

This post is intended to share my experience why it's so important to think about these techniques.

What is?

We can find lots of definitions over the internet but I like this definition I found on the internet:

“Continuous Delivery (CD) allows you to take the code stored in the repository and continuously deliver it to production. CI/CD creates a fast and effective process of getting your product to market before your competition as well as releasing new features and bug fixes to keep your current customers happy.“

Also I selected some pages you can read more about like Amazon, Google or Microsoft among other definitions.

In my opinion is a group of techniques or practices that helps us in the journey to create software products. I will share my experience as a developer to understand why I think it’s important to use those practices.

When we are developing it is common to use our local machines to develop and test the application that we are building. It's ok to do that but at some point we need to create environments where other people can take a look in order to use it or test it. Also we need to provide a way to set up a production environment with high availability and scalability.

To explain ideas I will use a simple web application project with 3 environments: 1) Local for development purposes, 2) Testing for testing purposes and 3) Production environment.

I will present the steps that we will do periodically in the process of building the web application.

1) Develop and test our features locally.
2) Deploy to our testing environment.
3) Test our old and new features in the test environment.
4) Continue the process of points 1, 2 and 3.
5) Deploy to production.

There are a lot of tasks that we need to do in all steps of development. For example creating the environments, the databases and other stuff. For example if we need to deploy to the testing environment we will have to do the following tasks: Update the database, Get the new code, Compile, Publish, Test among other tasks.

Imagine that you have to do all that task manually, also you have to do the same every time you want to deliver a new feature. Even worse, imagine that every environment has more than one machine, load balancer, more than one database.

Normally we think that we will waste a lot of time automating tasks but trust me that you will save a lot of time if you invest thinking on CI/CD.

Let’s start talking about some good practices we apply in this king of projects.

First of all we need to have our code in some repository, we have a lot of options there and we can recomend some of theme Github, GitLab. Also Google cloud has his own repository Cloud Source Repository.

Suppose we have three branches: develop, test and production. Each branch will have the code that we need in each environment. Think if everytime we push code to test something will prepare the test environment with the latest change for us. Also the same will happen for production or other environments we could have.

Ideally developers work on their own machines, pushing to different branches with automatic tasks that make the deployment for us. Deployment involves tasks like updating db with new data, compiling code, publishing code, run tests, etc.

We can automatize the tasks using different technologies that Google, Microsoft or Amazon among others can provide to us. In furute we will be talking about Cloud Build, the Google tool to do that.

In conclusion for me CI/CD are a group of techniques that make our work easier. It doesn't matter the tools or technologies that you use, It matters if you deliver your code as fast as you can with good quality.

In future posts I will be talking about some specific tools that Google and Amazon provide to us.