Explore the step-by-step process to install Phoenix along with Erlang and Elixir on your system. Understand the prerequisites and verify installations to prepare your environment for building real-time applications using Phoenix.

The following components should be installed on your system to run Phoenix applications locally.

• Erlang
• Elixir
• Phoenix

Installing Erlang

To install the Phoenix we need to install the Erlang. Erlang can be installed by running the following commands in our terminal:

apt-get update 
apt-get install -y wget 
rm -rf /var/lib/apt/lists/* 
wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb &&\
    dpkg -i erlang-solutions_2.0_all.deb || true
ARG DEBIAN_FRONTEND=noninteractive

Mac

brew update
brew install erlang

Erlang will be installed on our system.

Installing Elixir

We also need to install the Elixir to install Phoenix. Elixir can be installed by the following commands.

apt-get update &&\
apt-get install -y erlang &&\
apt-get install elixir

Elixir will be installed on our system.

Installing Phoenix

Before installing Phoenix, first, install local.hex as it is required to install Phoenix.

mix local.hex --force

To check the version of Elixir and Erlang, run the following:

elixir -v

After verifying the versions, install Phoenix by running the following command:

mix archive.install hex phx_new 1.5.9 --force

Phoenix will now be installed on our system.

Verify Phoenix version.

mix phx.new --version

To install and run Kafka and Zookeeper, you’ll need to follow a series of steps. Here’s a detailed guide:

Step 1: Install Java

Kafka requires Java to be installed on your machine. If you don’t have Java installed, you can install it using the following command:

sudo apt update
sudo apt install openjdk-11-jdk

Step 2: Download Kafka

The latest version of Kafka can be downloaded from the official website.

Step 3: Extract Kafka Files

Extract the downloaded files to the desired location on WSL Ubuntu.

tar -zvzf <downloaded_file.tgz>

Step 4: Start Zookeeper

Zookeeper is used by Kafka to manage and coordinate the Kafka brokers. To start Zookeeper, navigate to the Kafka directory and run the following command:

bin/zookeeper-server-start.sh config/zookeeper.properties

This will start Zookeeper using the default configuration.

Step 5: Start Kafka Broker

Once Zookeeper is running, you can start the Kafka broker. Open a new terminal window, navigate to the Kafka directory, and run:

bin/kafka-server-start.sh config/server.properties

This will start the Kafka broker with the default configuration.

Step 6: Create a Topic

You need to create a topic to start sending messages to Kafka. Run the following command to create a topic named test with a single partition and one replica:

bin/kafka-topics.sh --create --topic test --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

Step 7: Start a Producer

Now, you can start a Kafka producer to send messages to the topic test. Run the following command:

bin/kafka-console-producer.sh --topic test --bootstrap-server localhost:9092

Type some messages and press Enter to send them.

Step 8: Start a Consumer

To read messages from the topic test, you can start a Kafka consumer. Open a new terminal window and run:

bin/kafka-console-consumer.sh --topic test --from-beginning --bootstrap-server localhost:9092

You should see the messages you typed in the producer terminal.

And there you have it! You’ve successfully installed and set up Kafka and Zookeeper.

Stopping Zookeeper

To stop the Zookeeper server, you can use the following command:

bin/zookeeper-server-stop.sh

This will shut down the Zookeeper instance gracefully.

Stopping the Kafka Broker

To stop the Kafka broker, you can use this command:

bin/kafka-server-stop.sh

This command will shut down the Kafka broker gracefully.

Stopping the Producer and Consumer

If you started the Kafka producer and consumer using the console commands, you can stop them by simply closing the terminal windows where they are running, or by using Ctrl + C in the terminal.

Closing a Topic

You don’t need to “close” a topic explicitly. Topics in Kafka are persistent unless you delete them. If you wish to delete a topic, you can do so with the following command:

bin/kafka-topics.sh --delete --topic your_topic_name --bootstrap-server localhost:9092

Replace your_topic_name with the name of the topic you want to delete.

Following these steps will ensure all components of your Kafka setup are stopped. If you have any other questions or need further assistance, feel free to ask!

I forgot to add esbuild installation while scaffolding as follows:-

rails new aap-name -d postgresql - css=tailwind

Due to this reason, the application was not being styled properly. To fix this, I took the following steps.

Adding esbuild to a Rails application can help speed up your JavaScript builds. Here’s how you can do it:

1. Add the “jsbundling-rails” gem to your Gemfile:

gem 'jsbundling-rails'

2. Then, run the `bundle install` command to install the gem.

3. Then create a package.json file and add the following dependencies.

npm i @hotwired/turbo-rails
npm i @hotwired/stimulus
npm i @hotwired/stimulus-webpackers-helpers

3. Create a file esbuild.js in the config folder.

require('esbuild').build({ 
 entryPoints: ['app/javascript/application.js'], 
 bundle: true, 
 outdir: 'app/assets/builds', 
 sourcemap: true, 
 external: ['@hotwired/turbo-rails', 'controllers'], 
}).catch(() => process.exit(1))

4. Then, you should import your stimulus controllers in your `app/javascript/application.js` something like this:

import { Application } from "@hotwired/stimulus" 
import { definitionsFromContext } from "@hotwired/stimulus-webpack-helpers"
const application = Application.start() 
const context = require.context("./controllers", true, /\.js$/) 
application.load(definitionsFromContext(context))

5. Now, run the following command to set up esbuild:

./bin/rails javascript:install:esbuild

6. Now, you need to set up your package.json. Add these scripts to the “scripts” section in your package.json file:

"scripts": { 
 "build": "esbuild app/javascript/application.js - bundle - sourcemap - outdir=app/assets/builds", 
 "watch": "esbuild app/javascript/application.js - bundle - sourcemap - outdir=app/assets/builds - watch" 
}

7. To compile your JavaScript, you can now use the command `npm run build`. If you want your JavaScript to automatically compile whenever you make changes, use `npm run watch` instead.

8. Finally, you need to include the compiled JavaScript in your application layout. In `app/views/layouts/application.html.erb`, add the following line:

<%= javascript_include_tag 'application', "data-turbolinks-track": "reload" %>

Now you have added esbuild to your Rails application. Be sure to put your JavaScript code in `app/javascript/application.js` or import it from there. The `npm run build` or `npm run watch` commands will then compile your JavaScript and place it in `app/assets/builds/application.js` where it can be included in your layout.

Introduction to Cloud Native Computing

Cloud Native is a blueprint for building web-scale applications on the cloud that are more available and scalable. It promises increased agility to ship new features quickly without compromising availability, making it quicker to respond to changing customer demands. Cloud Computing is running applications on computing resources managed by cloud providers. Migrating an existing monolithic application from on-premise to the cloud frees the team from managing hardware infrastructure. For an application to be considered Cloud Native, there are at least 4 pillars to consider: application architecture, containers and container orchestration, development process, and platform primitives. Cloud Native offers benefits such as increased scalability, improved availability, and faster time to market.

Containerization and Orchestration

Docker containers provide a lightweight and efficient way to package and deploy applications. With containerization, developers can easily isolate their applications, making them more portable and scalable. Docker containers have revolutionized the way software is developed, deployed, and scaled in modern-day IT infrastructure. Developers can easily isolate their applications, making them more portable and scalable. Embracing containerization empowers teams to build, test, and deploy applications swiftly, fostering innovation and agility in the ever-evolving work landscape.”

Kubernetes is an open-source container orchestration platform that automates the deployment, scaling, and management of containerized applications. The name Kubernetes is abbreviated as k8s, with the 8 representing the number of letters between the first and last letter in the word. A Kubernetes cluster consists of control plane nodes and worker nodes, where the control plane manages the state of the cluster and the worker nodes run the containerized application workloads. The control plane includes core components such as the API server, etcd, scheduler, and controller manager. The worker nodes include components like the kubelet, container runtime, and kube-proxy. These components work together to ensure the proper functioning of the Kubernetes cluster.

Microservices

Microservices architecture enables large teams to build scalable applications composed of loosely coupled services. Each microservice handles a dedicated function and communicates with other microservices via well-defined interfaces. Microservices can be independently deployed and provide flexibility in scaling. However, breaking up the database poses a challenge in maintaining data integrity. Other critical components include API gateway, identity provider service, and service registry. Microservices architecture is suitable for large teams as it enables team independence and fast development. It may not be suitable for small startups due to the overhead involved.

Monitoring and Logging in Cloud Native Computing

Fluentd is an open source log data collector that helps address the challenges of collecting and consuming application logs. It allows for easy analysis and visualization of log data by providing a unified interface and format for logs from different applications and data sources. Applications can log data to files, but this makes analysis difficult without proper visualization. Logging directly into a log database like Elastic requires each application developer to add a library and configure it, posing additional challenges. Fluentd solves these challenges by providing a centralized solution for collecting logs from various sources in a unified format. It allows you to collect logs from third-party applications, system logs, and even requests that go through Nginx controller in a Kubernetes cluster. By consolidating all logs in one place, Fluentd enables efficient analysis and debugging of complex applications with tons of useful data.

Security and Cloud Native Computing

A cloud environment typically consists of standard workloads like application and database instances, as well as object storage. Bad actors target cloud environments to gain access, exfiltrate information, or cause disruption. They often exploit weak configurations, such as static passwords and lack of two-factor authentication. Public exposure of unencrypted data in object storage buckets is another common misconfiguration. Additionally, database instances, which should only be exposed to app or web instances, are sometimes found exposed to the internet, making them susceptible to brute force attacks. These misconfigurations pose security risks, and it’s crucial to monitor for suspicious behaviors to detect potential malicious activities. CloudTrail in AWS is an example of a tool that can help identify such behaviors. If the logging for CloudTrail gets disabled, it would be necessary to investigate whether it was done by a bad actor before any malicious activity occurs.

Copy the link of the nodejs binary and use wget in the terminal to download it or simply click on the download link from the official node.js website.

Move to the downloads directory or the directory where the above has been downloaded and extract its contents using the following replacing the filename.tar.xz with the actual name of the downloaded file.

tar -xvf filename.tar.xz

The options used in the command are as follows:

• -x: Extract files from the archive.
• -v: Display verbose output, showing the extracted files.
• -f: Specifies the input file.

Navigate into the extracted directory and copy its contents to the /usr/local directory.

cd extracted_folder
sudo cp -r * /usr/local/

Add Node.js to the Path.

nano ~/.bashrc
export PATH="/usr/local/bin:$PATH"
source ~/.bashrc

Verify the installation.

node -v
npm -v

Let’s create a new ruby on rails applications with esbuild and tailwind css. Generate a scaffold for posts entity and files related to adding notifications using the Stimulus framework.

rails new toast_notifications -j esbuild -c tailwind
cd toast_notifications
rails g scaffold post title text:string
rails g stimulus notifications

Next we add a gem named ‘Foreman’ that helps manage Procfile-based applications. It allows you to declare the various processes that are used in your application (such as web processes and worker processes) in a Procfile, and then use Foreman to manage these processes.

gem 'foreman', github: 'ddollar/foreman'
bundle i

Then we add Flowbite, an open-source library of UI components based on the utility-first Tailwind CSS framework. It features dark mode support, a Figma design system, templates, and more. Flowbite provides a robust set of design tokens and components based on the popular Tailwind CSS framework. From the most used UI components like forms and navigation bars to whole app screens designed for both desktop and mobile, this UI kit provides a solid foundation for any project.

Flowbite - Quickstart

<link href="https://cdnjs.cloudflare.com/ajax/libs/flowbite/1.6.5/flowbite.min.css" rel="stylesheet" />
<script src="https://cdnjs.cloudflare.com/ajax/libs/flowbite/1.6.5/flowbite.min.js"></script>

Create a new shared view with the name of _notifications.html.erb and add the following code in it from flowbite components’ documentation for toasts.

https://flowbite.com/docs/components/toast/

# app/views/shared/_notifications.html.erb
<% if message %>
<div id="toast-success" class="absolute bottom-5 right-5 flex items-center w-full max-w-xs p-4 mb-4 text-gray-500 bg-white rounded-lg shadow dark:text-gray-400 dark:bg-gray-800" role="alert">
    <div class="inline-flex items-center justify-center flex-shrink-0 w-8 h-8 text-green-500 bg-green-100 rounded-lg dark:bg-green-800 dark:text-green-200">
        <svg aria-hidden="true" class="w-5 h-5" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z" clip-rule="evenodd"></path></svg>
        <span class="sr-only">Check icon</span>
    </div>
    <div class="ml-3 text-sm font-normal"><%= message %></div>
    <button type="button" class="ml-auto -mx-1.5 -my-1.5 bg-white text-gray-400 hover:text-gray-900 rounded-lg focus:ring-2 focus:ring-gray-300 p-1.5 hover:bg-gray-100 inline-flex h-8 w-8 dark:text-gray-500 dark:hover:text-white dark:bg-gray-800 dark:hover:bg-gray-700" data-dismiss-target="#toast-success" aria-label="Close">
        <span class="sr-only">Close</span>
        <svg aria-hidden="true" class="w-5 h-5" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clip-rule="evenodd"></path></svg>
    </button>
</div>
<% end %>

Note that the message has been further customized with the addition if condition along with its positioning.

After that, render the partial view by adding the following line above ≤% yield %> in application.html.erb.

<%= render partial: "shared/notifications", locals: { message: flash[:notice] } %>
<%= yield %>

Run bin/dev. Create & run pending migrations and create a new post.

Now, our message is being displayed quite nicely, however, to make it disappear, we will have to add the stimulus-notification dependency which is a stimulus controller for showing notifications.

https://www.stimulus-components.com/docs/stimulus-notification

npm i stimulus-notification

We make use of inheritance to extend the functionality of any Stimulus Component by changing the content of notifications_controller.js as follows.

import Notification from 'stimulus-notification'

export default class extends Notification {
  connect() {
    super.connect()
    console.log('Do what you want here.')
  }
}

Finally in our view, we add data-controller properties to our div element.

# app/views/shared/_notifications.html.erb
<% if message %>
<div id="toast-success"
     class="transition transform duration-1000 absolute bottom-5 right-5 flex items-center w-full max-w-xs p-4 mb-4 text-gray-500 bg-white rounded-lg shadow dark:text-gray-400 dark:bg-gray-800" 
     role="alert"
     data-controller="notifications"
     data-notification-hidden-value="true"
     data-transition-enter-from="opacity-0 translate-x-6"
     data-transition-enter-to="opacity-100 translate-x-0"
     data-transition-leave-from="opacity-100 translate-x-0"
     data-transition-leave-to="opacity-0 translate-x-6"

     >
    <div class="inline-flex items-center justify-center flex-shrink-0 w-8 h-8 text-green-500 bg-green-100 rounded-lg dark:bg-green-800 dark:text-green-200">
        <svg aria-hidden="true" class="w-5 h-5" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z" clip-rule="evenodd"></path></svg>
        <span class="sr-only">Check icon</span>
    </div>
    <div class="ml-3 text-sm font-normal"><%= message %></div>
    <button type="button" data-action="notifications#hide" class="ml-auto -mx-1.5 -my-1.5 bg-white text-gray-400 hover:text-gray-900 rounded-lg focus:ring-2 focus:ring-gray-300 p-1.5 hover:bg-gray-100 inline-flex h-8 w-8 dark:text-gray-500 dark:hover:text-white dark:bg-gray-800 dark:hover:bg-gray-700" data-dismiss-target="#toast-success" aria-label="Close">
        <span class="sr-only">Close</span>
        <svg aria-hidden="true" class="w-5 h-5" fill="currentColor" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><path fill-rule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clip-rule="evenodd"></path></svg>
    </button>
</div>
<% end %>

Now, we have sliding notifications to go along with our rails notices which vanish automatically after the lapse of one second.

!pip install - upgrade pip
!pip install openai

Create an account on beta.openai.com and generate an api key. Save the api key in a variable as follows:-

OPENAI_API_KEY = "**********************************************"

Import the OpenAI library and set the API key required to access OpenAI resources.

import openai
openai.api_key = OPENAI_API_KEY

Define a function named “chat” that uses the GPT-3.5 model to generate a response to a user’s question. The consolidated code should look like as follows:-

import openai
OPENAI_API_KEY = "**********************************************"
openai.api_key = OPENAI_API_KEY

def chat(question):
  response = openai.ChatCompletion.create(
      model = "gpt-3.5-turbo",
      messages = [
          {
              "role": "user",
              "content": question
          }
      ]
  )

  return response

Save the response in a variable and print it as follows.

response = chat("Write a poem on Python's zen ?")
answer = response.choices[0].message.content
print(answer)

Python’s zen is a thing of grace,

A philosophy birthed in code’s embrace,

A set of rules to guide a way,

Ensuring elegance in every display.

This language of Monty’s creation,

A designer’s tool for exploration,

Embraces simplicity with ease,

Granting power to code with breeze.

It teaches us to strive for clarity,

In our coding, in our proclivity,

To craft programs that are readable,

Ensuring they’re reusable, and not disposable.

Beautiful code is art in motion,

And Python’s zen is the ultimate potion,

To bring forth the best in our design,

And write solutions that are sublime.

So let’s embrace the Python way,

And code with grace and skill each day,

For Python’s zen is the heart of it all,

And its magic weaves a lasting thrall.

rails new devise-vue --api -T -d postgresql
cd devise-vue
bundle add devise devise-jwt rack-cors

In the config/initializers/cors.rb file set the origins to all and expose the Authorization and Uid of the resource.

Rails.application.config.middleware.insert_before 0, Rack::Cors do
  allow do
   #origins "example.com" # Replace this line with following
   origins "*"

    resource "*",
      headers: :any,
      methods: [:get, :post, :put, :patch, :delete, :options, :head],
      # Add the following line
      expose: %w[Authorization Uid]
  end
end

Install devise and generate default User.

rails g devise:install
rails g devise User

Generate Model jwt_denylist with jwt and exp columns.

rails g model jwt_denylist jti:string exp:datetime

Change the name of individual migration file db/migrate/………_create_jwt_denylists.rb as well as the table’s name contained therein to singular which was generated after the above mentioned command. Make the two columns ‘jti’ and ‘exp’ non-null by adding ‘null: false’ property and add index on column ‘jti’ rendering the aforementioned file as follows.

#db/migrate/………_create_jwt_denylist.rb
class CreateJwtDenylist < ActiveRecord::Migration[7.0]
  def change
    create_table :jwt_denylist do |t|
      t.string :jti, null: false
      t.datetime :exp, null: false

      t.timestamps
    end
    add_index :jwt_denylist, :jti
  end
end

Remove recoverable, rememberable and validatable attribute from devise in the model app/models/user.rb and add jwt_authenticatable, jwt_revocation_strategy amd JwtDenylist attributes to the same. This will setup a way to log out a user or expire a user session by just inserting the token to deny the jwt, hence, the user itself ought not to be modified, a very nice alternative for logging out the user.

# app/models/user.rb
class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :jwt_authenticatable, jwt_revocation_strategy: JwtDenylist
end

Link the Devise and JWT attributes in the jwt_denylist model.

# app/models/jwt_denylist.rb
class JwtDenylist < ApplicationRecord
  include Devise::JWT::RevocationStrategies::Denylist
  
  self.table_name = 'jwt_denylist'
end

Next, create and migrate the database.

rails db:create db:migrate

Now, create the members controller which shows the information if a user is logged in.

#app/models/members_controller.rb

class MembersController < ApplicationControler
  before_action :authenticate_user!

  def show
    user = get_user_from_token
    render json: {
      message: "If you see this, you're in",
      user: user
    }
    end

    private

    def get_user_from_token
      jwt_payload = JWT.decode(request.headers['Aurhorization'].split(' '[1],
                    Rails.application.credentials.devise[:jwt_secret_key]).first
      user_id = jwt_payload['sub']
      user = User.find(user_id.to_s)
    end
end

Then, lets generate the files named registrations_controller and sessions_controller in a new folder called users inside the controller folder.

#app/controllers/users/registrations_controller.rb
class Users::RegistrationsController < Devise::RegistrationsController
    respond_to :json
    private
    def respond_with(resource, _opts = {})
        register_success & return if resource.persisted?

        register_failed
    end

    def register_success
        render json: {
            message: 'Signed up successfully.',
            user: current_user
        }, status: :ok
    end

    def register_failed
        render json: {  message: 'Something went wrong.'}, status: :unprocessable_entity
    end
end

#app/controllers/users/sessions_controller.rb
class Users::SessionsController < Devise::SessionsController
    respond_to :json

    private

    def respond_with(_resource, _opts = {})
      render json: {
        message: 'You are logged in.',
        user: current_user
      }, status: :ok
    end

    def respond_to_on_destroy
      log_out_success && return if current_user
      
      log_out_failure
    end

    def log_out_success
        render json: {
            message: 'You are logged out.'
        }, status: :ok
    end

    def log_out_failure
        render json: {
            message: 'Something went wrong.'
        }, status: :unauthorized
    end
end

After that, encode the jwt secret key in the credentials.yml. Run the following in the terminal and copy the generated secret.

rails secret

Open the nano editor.

EDITOR=nano rails credentials:edit

Paste the generated secret in the credentials.yml.

devise:
  jwt_secret_key: <your_secret_key>

Finally,in the routes, hook up the newly created controllers to override the device controllers as follows:-

# config/routes.rb
Rails.application.routes.draw do
  devise_for :users,
  controllers: {
    sessions: 'users/sessions',
    registrations: 'users/registrations'
  }

  get '/member-data', to: 'members#show'
end

Now, if you run the server and post the following request to https://localhost:3000/users in the rapid api extension of the vs code, you will get the 500 internal server error inferring that the application has sessions disabled.

So, lets enable the sessions after which the application.rb should something like this.

# config/application.rb

require_relative "boot"

require "rails/all"

# Require the gems listed in Gemfile, including any gems
# you've limited to :test, :development, or :production.
Bundler.require(*Rails.groups)

module DeviseVue
  class Application < Rails::Application
    # Initialize configuration defaults for originally generated Rails version.
    config.load_defaults 7.0

    # Configuration for the application, engines, and railties goes here.
    config.load_defaults 7.0
    #
    # This also configures sessions_options for use below
    config.session_store :cookie_store, key: '_interslice_session'
    # Required for all session management (regardless of session_store)
    config.middleware.use ActionDispatch::Cookies
    config.middleware.use ActionDispatch::Session::CookieStore, config.session_options

    # These settings can be overridden in specific environments using the files
    # in config/environments, which are processed later.
    #
    # config.time_zone = "Central Time (US & Canada)"
    # config.eager_load_paths << Rails.root.join("extras")

    # Only loads a smaller set of middleware suitable for API only apps.
    # Middleware like session, flash, cookies can be added back manually.
    # Skip views, helpers and assets when generating a new resource.
    config.api_only = true
  end
end

Run the rails server again after enabling the sessions and post another request to https://localhost:3000/users, but this time with a different email, as the first one actually did get committed to the database. The response shall be 200.

Step 1

Go to EC2 on you aws console. Launch an instance by selecting an Ubuntu 22.04 image. Choose the instance type according to the requirements of the project. Select an existing or create a new key/value pair and save it your local machine.

After filling the specifications, launch the instance.

Step 2

Move the downloaded key-value pair in a separate folder. Copy the public IPv4 address mentioned alongside the name of the running aws instance. Open the terminal and create a secure shell connection with the copied remote IPv4 address.

sudo chmod 600 key-value-pair.pem
ssh ubuntu@your.remote.ipv4.address -i key-value-pair.pem

Step 3

Once logged into the secure shell, create ssh key. At the same time, update and upgrade the packages existing on the machine instance.

sudo apt update && sudo apt upgrade
sudo apt install curl git
ssh-keygen
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_rsa

Copy the ssh key.

cat .ssh/id_rsa.pub

Add it in the settings of your Github Profile.

Step 4

Manage multiple runtime versions with a single CLI tool, extendable via plugins — docs at asdf-vm.com

asdf is a CLI tool that can manage multiple language runtime versions on a per-project basis. It is like gvm, nvm, rbenv & pyenv (and more) all in one! Simply install your language's plugin!

Also add the environment variables to .bashrc through script.

git clone git@github.com:asdf-vm/asdf.git ~/.asdf --branch release-v0.9.1
echo '. $HOME/.asdf/asdf.sh' >> ~/.bashrc
echo '. $HOME/.asdf/completions/asdf.bash' >> ~/.bashrc
source ~/.bashrc

Add dependencies required for adding the ruby plugin. Then add plugin ruby and install ruby and ruby on rails.

sudo apt install build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libreadline-dev libffi-dev gcc
apt-get install autoconf bison patch build-essential rustc libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libgmp-dev libncurses5-dev libffi-dev libgdbm6 libgdbm-dev libdb-dev uuid-dev

asdf plugin add ruby
asdf install ruby latest
ruby -v
asdf global ruby [version]
sudo apt install ruby-railties
rails -v

Step 5

Add PostgreSQL Database and aws cli.

sudo apt install postgresql-contrib libpq-dev postgresql
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
sudo apt install unzip jq
unzip awscliv2.zip
sudo ./aws/install

Step 6

Create a Postgres User and add/confirm password. Then set the password for postgres user ubuntu.

sudo -u postgres createuser -s ubuntu -P
sudo -u postgres psql

postgres=# \password ubuntu
Enter new password for user "ubuntu":
Enter it again:
postgres=# \q

Create and Migrate the database. Add node, npm and Yarn.

rails db:create && rails db:migrate
sudo apt install nodejs -y
sudo apt install npm -y
sudo npm i -g yarn

Step 6

Deploy

rails s -p 3003 -b 0.0.0.0