DEV Community: Roseline Bassey

Android App: Instrumented and Unit Tests Automation Using CircleCI

Roseline Bassey — Wed, 10 May 2023 09:17:05 +0000

As an Android developer, testing is an integral part of the app development process. By running tests you can verify your app’s functional behaviour, correctness, and usability before you release it to the public. CircleCI is a CI platform that supports running Android emulators from within an Android machine image. We will use CircleCI to set up automated testing for our project. Automated testing involves using tools that perform tests on the project for you, which is faster, repeatable, and gives you more actionable feedback about your app earlier in the development process.

This article describes how to automate instrumentation and unit tests for an open source Android project using CircleCI. I assume you already know how to create an Android app and write tests for your app. The cloned project and working pipeline can be found here.

Instrumentation Testing

Instrumented tests, also known as instrumentation tests, are tests that run on Android devices, whether physical or emulated. It involves testing the overall behaviour of an application by testing the interaction between different components. It checks how the application performs when different components work together, including user interfaces, APIs, and external dependencies. This type of testing helps identify issues that may arise due to interactions between components, such as compatibility issues or performance problems.

Unit Testing

Unit testing involves testing individual components or units of code in isolation to verify their functionality, usually a single class or function. In unit testing, each unit of code is tested separately from the rest of the codebase to ensure that it behaves as expected.

CircleCI

CircleCI is a hosted and automated solution for continuous integration (CI) builds. It uses an in app configuration file that uses YAML syntax. CircleCI is easier to set up and is hosted in the cloud. After learning about instrumentation tests, unit testing, and CircleCI, we can now learn how testing in CI/CD works.

Unit Testing and Instrumentation Testing in CI/CD

As a DevOps principle, it is a good practice to automate testing as part of the CI process to test your code against any bug. Automated tests can be triggered at various stages of your CircleCI pipeline, including development, staging, and/or production. An effective automated test runs immediately after changes are committed to the version control system's (for example, GitHub) staging or development repository. If the test meets the success criteria, then the committed change(s) may proceed to the next stage or environment. If the test failed, the committed changes are blocked from proceeding until those issues are resolved. By automating tests, teams can have confidence that code changes have been thoroughly tested and have met the success and quality standards, thereby, protecting the production environment against disruptions.

Setting up Automated Android Testing on CircleCI

Firstly, we will set up our config.ymlfile to run unit tests. I'll demonstrate two approaches for running instrumentation tests on CircleCI: using the No-orb and Orb examples. The No-orb example is a more complex process because you would have to write the steps yourself, while the CircleCI Android orb example is an easy process with many steps already written for you. There's no need to worry, the No-orb example is not as difficult as it seems because CircleCi offers clear documentation that will make setup simple. Please take note that you should only use one of the examples in your config.yml file. The two instances given here are merely for demonstration. Let's get started.

Create a `circleci.yml` File

At the root of your project’s folder, create a .circleci folder. Inside the folder create a config.yml file. Our workflow will be in this order:

Unit Tests
Instrumentation Tests

Running Unit Test

We will call our job unit-tests. The working_directory specifies the location of the project files. The docker image section specifies the Docker image to use. In this case, it uses the cimg/android:2023.02 image.

Here’s a full look at the unit test job:



jobs:
version: 2.
unit-tests:
    working_directory: ~/project
    docker:
      - image: cimg/android:2023.02
    steps:
      - checkout
      - run:
          name: Run Unit Tests
          command: |
            ./gradlew clean test
        - store_test_results:
            path: app/build/test-results

The steps section includes three steps: first CircleCI checks out the repository where the code is stored. Then, run unit tests using the ./gradlew clean test command, and store the test results at the path specified.

Running Instrumentation Tests

As I mentioned earlier, there are different approaches to doing this. We will cover two examples or approaches. The first example is the No-orb example.

Using the No-orb Example

Our instrumented test requires an emulator to run on a machine image. Below is a breakdown of the instrumentation tests job. The full code is provided below. We will add each step to the instrumented test job in the circleci.yml file.



jobs:
instrumented_test:
    machine:
      image: android:202102-01
    resource_class: large

So in the instrumented test job, we specify the image: android:202102-01 as the machine image and set the resource_class of the machine as "large" to improve build time. Under the step section we have the following steps:



steps:
      - checkout
      - run:
          name: Create avd
          command: |
            SYSTEM_IMAGES="system-images;android-29;default;x86"
            sdkmanager "$SYSTEM_IMAGES"
            echo "no" | avdmanager --verbose create avd -n test -k "$SYSTEM_IMAGES"

The - checkout checks out the code from the repository while the command under - Create avd installs the Android system image required for the emulator to run, and creates a new virtual device named "test".



- run:
          name: Launch emulator
          command: |
            emulator -avd test -delay-adb -verbose -no-window -gpu swiftshader_indirect -no-snapshot -noaudio -no-boot-anim
          background: true

The Launch emulator command launches the emulator and waits for it to start up. It runs in the background (background: true) so that other steps can execute in parallel.



 - run:
          name: Generate cache key
          command: |
            find . -name 'build.gradle' | sort | xargs cat |
            shasum | awk '{print $1}' > /tmp/gradle_cache_seed

The Generate cache key command generates a cache key based on the contents of the build.gradle files in the project. This key is used to restore the Gradle cache later, to speed up the build process.



  - restore_cache:
          key: gradle-v1-{{ arch }}-{{ checksum "/tmp/gradle_cache_seed" }}

restore_cache step attempts to restore the Gradle cache from a previous build, using the cache key generated in the previous step.



- run:
          # run in parallel with the emulator starting up, to optimize build time
          name: Run assembleDebugAndroidTest task
          command: |
            ./gradlew assembleDebugAndroidTest

assembleDebugAndroidTest command compiles and build the debug version of the Android test APK and runs in parallel with the emulator starting up, to optimize build time.

This step can be modified to suit your project needs. I modified the above☝️ step to this:👇



 - run:
          # run in parallel with the emulator starting up, to optimize build time
          name: Run compileDemoBasicDebugJavaWithJavac task
          command: |
            ./gradlew compileDemoBasicDebugJavaWithJavac

This step compiles the Java code in the project using the javac compiler. This runs in parallel with the emulator starting up, to optimize build time.



  - run:
          name: Wait for emulator to start
          command: |
            circle-android wait-for-boot

As the name implies, the Wait for emulator to startstep waits for the emulator to finish booting up and become available for testing.



   - run:
          name: Disable emulator animations
          command: |
            adb shell settings put global window_animation_scale 0.0
            adb shell settings put global transition_animation_scale 0.0
            adb shell settings put global animator_duration_scale 0.0

The Disable emulator animations step disables the emulator animations to speed up the testing process.



 - run:
          name: Run UI tests (with retry)
          command: |
            MAX_TRIES=2
            run_with_retry() {
               n=1
               until [ $n -gt $MAX_TRIES ]
               do
                  echo "Starting test attempt $n"
                  ./gradlew connectedAndroidTest && break
                  n=$[$n+1]
                  sleep 5
               done
               if [ $n -gt $MAX_TRIES ]; then
                 echo "Max tries reached ($MAX_TRIES)"
                 exit 1
               fi
            }
            run_with_retry

Run UI tests (with retry) runs the instrumented tests on the emulator, with a retry mechanism in case of failures. The connectedAndroidTest command is the main command which runs the tests.



 - save_cache:
          key: gradle-v1-{{ arch }}-{{ checksum "/tmp/gradle_cache_seed" }}
          paths:
            - ~/.gradle/caches
            - ~/.gradle/wrapper

save_cache saves the Gradle cache for future builds, using the cache key generated earlier.

Let's take a look at the whole config.yml file, which includes both the unit tests and the instrumentation tests jobs:



jobs:
version: 2.
unit-tests:
    working_directory: ~/project
    docker:
      - image: cimg/android:2023.02
    steps:
      - checkout
      - run:
          name: Run Unit Tests
          command: |
            ./gradlew clean test

      - store_test_results:
          path: app\build\test-results

instrumented_test:
    machine:
      image: android:202102-01
    resource_class: large
    steps:
      - checkout
      - run:
          name: Create avd
          command: |
            SYSTEM_IMAGES="system-images;android-29;default;x86"
            sdkmanager "$SYSTEM_IMAGES"
            echo "no" | avdmanager --verbose create avd -n test -k "$SYSTEM_IMAGES"
      - run:
          name: Launch emulator
          command: |
            emulator -avd test -delay-adb -verbose -no-window -gpu swiftshader_indirect -no-snapshot -noaudio -no-boot-anim
          background: true
      - run:
          name: Generate cache key
          command: |
            find . -name 'build.gradle' | sort | xargs cat |
            shasum | awk '{print $1}' > /tmp/gradle_cache_seed
      - restore_cache:
          key: gradle-v1-{{ arch }}-{{ checksum "/tmp/gradle_cache_seed" }}
      - run:
          # run in parallel with the emulator starting up, to optimize build time
          name: Run assembleDebugAndroidTest task
          command: |
            ./gradlew assembleDebugAndroidTest
      - run:
          name: Wait for emulator to start
          command: |
            circle-android wait-for-boot
      - run:
          name: Disable emulator animations
          command: |
            adb shell settings put global window_animation_scale 0.0
            adb shell settings put global transition_animation_scale 0.0
            adb shell settings put global animator_duration_scale 0.0
      - run:
          name: Run UI tests (with retry)
          command: |
            MAX_TRIES=2
            run_with_retry() {
               n=1
               until [ $n -gt $MAX_TRIES ]
               do
                  echo "Starting test attempt $n"
                  ./gradlew connectedAndroidTest && break
                  n=$[$n+1]
                  sleep 5
               done
               if [ $n -gt $MAX_TRIES ]; then
                 echo "Max tries reached ($MAX_TRIES)"
                 exit 1
               fi
            }
            run_with_retry
      - save_cache:
          key: gradle-v1-{{ arch }}-{{ checksum "/tmp/gradle_cache_seed" }}
          paths:
            - ~/.gradle/caches
            - ~/.gradle/wrapper
      - store_test_results:
          path: app\build\outputs\androidTest-results

Using Android Orb Example

Since CircleCi has already done some of the work, this step is a bit shorter than the first example. So, you can use this instead of the No-orb example and it'll still function the same.




version: 2.1
orbs:
  android: circleci/android@2.1.2
jobs: 
  android-test:
    executor:
      name: android/android-machine
      tag: "202102-01"
      resource-class: large
    #run instrumentation tests

    steps:
      - checkout
      - run:
          name: installing emulator and Running Instrumentation tests
          command:  |
            sdkmanager "platform-tools" "platforms;android-29" "build-tools;30.0.0" "emulator"
            sdkmanager "system-images;android-29;google_apis;x86"
            echo no | avdmanager create avd -n test-emulator -k  "system-images;android-29;google_apis;x86"
            emulator -avd test-emulator -noaudio -no-boot-anim -gpu off -no-window &
            adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;'
            adb shell wm dismiss-keyguard
            sleep 1
            adb shell settings put global window_animation_scale 0
            adb shell settings put global transition_animation_scale 0
            adb shell settings put global animator_duration_scale 0
            ./gradlew connectedAndroidTest

It's time to see our CI test in action on CircleCI.

How to Setup CircleCI

Make sure you have created at the root of your project’s folder, a .circleci folder, and inside of the folder you have a config.yml file. Before moving on to CircleCI, let's add a build job at the beginning of the config.yml file and define the workflow of our build pipeline at the end of the file. Using the no-orb example, the final config.yml file will look like this:



version: 2.1
jobs:
  build:
    working_directory: ~/project
    docker:
      - image: cimg/android:2023.02
    steps:
      - checkout
      - restore_cache:
          keys:
            - v1-dependencies-{{ checksum "build.gradle" }}
            - v1-dependencies-
      - run:
          name: Install dependencies
          command: ./gradlew androidDependencies

      - save_cache:
          paths:
            - ~/.gradle
            - ~/.android
          key: v1-dependencies-{{ checksum "build.gradle" }}

      - run:
          name: Build project
          command: ./gradlew clean assemble

unit tests:
    working_directory: ~/project
    docker:
      - image: cimg/android:2023.02
    steps:
      - checkout
      - run:
          name: Run Local UnitTests
          command: |
            ./gradlew clean test

      - store_test_results:
          path: app\build\test-results


  instrumented_test:
    machine:
      image: android:202102-01
    resource_class: large
    steps:
      - checkout
      - run:
          name: Create avd
          command: |
            SYSTEM_IMAGES="system-images;android-29;default;x86"
            sdkmanager "$SYSTEM_IMAGES"
            echo "no" | avdmanager --verbose create avd -n test -k "$SYSTEM_IMAGES"
      - run:
          name: Launch emulator
          command: |
            emulator -avd test -delay-adb -verbose -no-window -gpu swiftshader_indirect -no-snapshot -noaudio -no-boot-anim
          background: true
      - run:
          name: Generate cache key
          command: |
            find . -name 'build.gradle' | sort | xargs cat |
            shasum | awk '{print $1}' > /tmp/gradle_cache_seed
      - restore_cache:
          key: gradle-v1-{{ arch }}-{{ checksum "/tmp/gradle_cache_seed" }}
      - run:
          # run in parallel with the emulator starting up, to optimize build time
          name: Run compileDemoBasicDebugJavaWithJavac task
          command: |
            ./gradlew compileDemoBasicDebugJavaWithJavac
      - run:
          name: Wait for emulator to start
          command: |
            circle-android wait-for-boot
      - run:
          name: Disable emulator animations
          command: |
            adb shell settings put global window_animation_scale 0.0
            adb shell settings put global transition_animation_scale 0.0
            adb shell settings put global animator_duration_scale 0.0
      - run:
          name: Run UI tests (with retry)
          command: |
            MAX_TRIES=2
            run_with_retry() {
               n=1
               until [ $n -gt $MAX_TRIES ]
               do
                  echo "Starting test attempt $n"
                  ./gradlew connectedAndroidTest && break
                  n=$[$n+1]
                  sleep 5
               done
               if [ $n -gt $MAX_TRIES ]; then
                 echo "Max tries reached ($MAX_TRIES)"
                 exit 1
               fi
            }
            run_with_retry
      - save_cache:
          key: gradle-v1-{{ arch }}-{{ checksum "/tmp/gradle_cache_seed" }}
          paths:
            - ~/.gradle/caches
            - ~/.gradle/wrapper
      - store_test_results:
          path: app\build\outputs\androidTest-results

workflows:
  build_and_deploy:
    jobs:
      - build
      - instrumented_test:
          requires:
            - build
      - unit tests:
          requires:
            - build

Next, login to CircleCI using your GitHub, BitBucket, or GitLab account. In the CircleCI web, click on projects at the sidebar and then select which project on your version control you want CircleCI to build on. In my case, I selected the androidlibraryproject.

In the “Select your config.yml file” modal, select Fastest, and a pop-up will appear like so:

Under fastest select to choose your preferred project and the branch where the project is located, then click Set Up Project to start building your project on CircleCI. You can monitor the build process on your dashboard. On a successful build, you'll have a green build like below:

Note that the instrumentation tests job may take a few more minutes than other jobs to build. The time taken is solely dependent on your project. It took almost five minutes for the instrumentation test to finish building in my case.

Recap

In this article, you learned how to automate testing for your Android project using CircleCI. How to set up unit tests and also learned two approaches to setting up instrumentation tests on CirCleCI. You've learned the benefits of automating testing in CI and you've seen the CI test in action on CircleCI.

How to Set Up an Nginx Web Server in Ubuntu Virtual Machine Using Vagrant

Roseline Bassey — Fri, 05 May 2023 16:16:55 +0000

If you explore many Developers and DevOps toolkits, you'll likely come across Vagrant - a tool that is widely used by teams to develop virtual environments that mirror the production environment. One of the advantages of using Vagrant is its ability to reduce the occurrence of bugs or issues before delivering code to the production environment.

In this project tutorial, you'll gain insight into the process of setting up an Nginx web server on Ubuntu, along with how to manually and automatically replace the Nginx default page with an actual web page using Vagrant. By the end of this tutorial, you'll have learned how to:

Install Vagrant and VirtualBox on your local machine.
Set up Ubuntu virtual machine in VirtualBox using Vagrant
Set up an Nginx web server on Ubuntu to host a web page.
Replace the default Nginx web server home page with our web application.
Automatically host our web page on Nginx using Vagrant.
Validate and access it from your local machine's web browser.

Vagrant

Vagrant is an open source tool for creating and managing reproducible virtual development environments that run on any machine. It manages virtual machines with a configuration file called Vagrantfile. This file is sharable and controls the lifecycle of a virtual machine, including starting, halting, and provisioning them. Let's imagine you have a Vagrantfile that was created by someone else on your computer. You can replicate the same environment or virtual machine (VM) as the original with merely the "vagrant up" command.
In 2010, HashiCorp created Vagrant, which is widely used in the technological stacks of organizations including Airbnb, Accenture, Coursera, and Shopify. Several virtualization service providers, including VirtualBox, VMware, Docker, and Hyper-V, are supported by Vagrant.

VirtualBox

VirtualBox is a free virtualization software that helps users run a second computer with a different operating system from their host computer. As in our case, we will run an Ubuntu operating system in VirtualBox separate from our Windows host computer. VirtualBox supports a variety of operating systems, including Windows, Linux, and macOS. It also comes with some nice features. For example, it supports virtual networking, which enables communication between virtual machines and the host computer. When testing network configurations or running servers in a virtual environment, this can be incredibly helpful.

Ubuntu

Ubuntu is one of the most widely used Linux distributions based on the Linux Kernel. In this tutorial, this will be utilized to run our web server.

NGINX

Nginx is a popular web server software that is widely used to host both static and dynamic web pages that can be accessed by users over the internet.

Before You Dive In

As a prerequisite, your computer needs to have around 10GB of free disk space and at least 8GB of RAM to run Linux in a virtual machine.
Follow the instructions provided in the official VirtualBox documentation to download and install VirtualBox
Similarly, download and install Vagrant by following the instructions provided on the official Vagrant documentation.

Creating an Ubuntu Virtual Machine Using Vagrant

Assuming you have your VirtualBox and Vagrant installed, we'll begin by setting up a virtual machine using Vagrant. We need to first create a new directory on our desktop. To do this, use your Windows Command Prompt or Windows Powershell to execute the following commands:



cd Desktop       
mkdir myproject
cd myproject
vagrant init

Your terminal should look like this:

At line 1 you used the cd command to navigate into your desktop environment. While in line 2, you used the mkdir command to create a new folder or directory called myproject on your desktop. Next, you cd into the newly created directory in line 3. Then, you initialize a new vagrant machine in line 4.

After executing the command at line 4, you’ll notice that a Vagrantfile has been created inside your directory. Let's add some setup to our 'Vagrantfile' before starting our virtual environment.

Launch the Vagrantfile using a code editor. In this tutorial, I'm using Visual Studio Code.
Edit the file by adding the following code:



Vagrant.configure("2") do |config|


### Nginx VM ###
  config.vm.define "web01" do |web01|
    web01.vm.box = "ubuntu/bionic64"
    web01.vm.hostname = "web01"
    web01.vm.network "private_network", ip: "192.168.56.18"
    web01.vm.provider "vmware_desktop" do |vmware|
      vmware.gui = true
      vmware.allowlist_verified = true
    end
  end

end

Let me explain what the file does. This Vagrant configuration file specifies a virtual machine with the name "web01" that will run an Ubuntu Bionic 64-bit operating system. Here's what each line does:



Vagrant.configure("2") do |config|

Starts the Vagrant configuration block and specifies that version 2 of the configuration API should be used.



config.vm.define "web01" do |web01|

Creates a new virtual machine named web01 and defines its settings.



web01.vm.box = "ubuntu/bionic64"

Sets the base box image to ubuntu/bionic64.



web01.vm.hostname = "web01"

Sets the hostname of the virtual machine to web01.



web01.vm.network "private_network", ip: "192.168.56.18"

Adds a private network interface to the virtual machine with an IP address of 192.168.56.18.



web01.vm.provider "vmware_desktop" do |vmware|

Sets the virtualization provider to vmware_desktop and defines its settings.



vmware.gui = true

Enables the GUI mode for the virtual machine.



vmware.allowlist_verified = true

serves as a setting that VMware box has been properly configured for allow list VMX settings.

Finally, the end tags closes the Vagrant.configure, config.vm.define, and the Vagrant.configure blocks respectively.

Note: If the IP address "192.168.56.18" is already in use on your computer, you can select an alternative "IP" address.

Launch the virtual machine using:



vagrant up

This will take a few minutes to boot up the VM. Login to the web01 VM using the command:



vagrant ssh web01

Your directory should change to vagrant@web01:~$ if successful just as in the image above.

Verify Hosts entry



cat /etc/hosts

Update the Ubuntu operating system with the latest patches by running the following commands:



sudo apt update
sudo apt upgrade

Install Nginx:



sudo apt install nginx -y

After installing Nginx, let's check that it's up and running with the command:



systemctl status nginx

The nginx web server is active (running) as seen in the image above.

Accessing Nginx Web Server on Browser

After setting up our VM and installing Nginx, we can now access our web server in a browser using the private IP address that we previously defined in our Vagrantfile.

To confirm that our virtual machine's network setting is as specified in the Vagrantfile, which is ip: 192.168.56.18. Inside the SSH session, run:



ip addr

You should have an output similar to the one seen in the image above. The output verifies that the VM’s IP address is set to 192.168.56.18 and we can access the web server in our browser using the IP address.
Open your browser and enter “http:// Your IP ADDRESS”. For instance, http://192.168.56.18.

Nginx Demo Page

Good job if you've made it this far.The default Nginx page serves as a confirmation that Nginx is installed and running correctly. In the next section, We'll explore the steps in replacing the default Nginx page with our website so that users can see our content right away.

You can change the appearance of the Nginx demo page by modifying the default index.html file. To edit the file, run the following commands:



cd /var/www/html
ls -al

This will cd into the /var/www/html directory and list all the files in the directory
You’ll see a file called index.html or as in my case index.nginx-debian.html

Use nano editor to edit the file:



sudo nano index.nginx-debian.html
or
sudo nano index.html

Your output should look like this:

You can proceed to edit the page to give it the appearance you desire. As an example, you can either add a background color or an image. Press ctrl+o to save the edited file, and ctrl+x to close the nano editor. Type logout to exit the Ubuntu virtual machine.

Replace the Default Page with your Website

We will upload an actual website in place of the default Nginx page in this section. The source code for this tutorial can be accessed via a GitHub link. I have modified Dinesh Pandiyan’s simple html and css open source landing page to make it uniquely mine. You can personalize this as well.

Create a new folder called samplepage in the myproject directory which we previously created. Make sure you’re in the root directory before executing this command:



mkdir samplepage

You can either clone the samplepage folder from GitHub or use your preferred web page content.

Run the following commands:



vagrant ssh web01

to move inside the virtual machine.
Inside the virtual machine, run the following:



cd /vagrant
ls
sudo cp -r /vagrant/samplepage/* /var/www/html/

When you start a Vagrant virtual machine, a shared folder is created between the two machines, which is mapped to the /vagrant directory in the guest machine. Any files or directories placed in your project directory on the host machine are automatically synced to the /vagrant directory in the guest machine. This means that Vagrant shares our project folder (myproject) with the guest machine so we can access it from within the VM.

In the code above:

cd /vagrant - This command changes the current working directory to /vagrant.
ls - This command lists and displays the names of all files and directories in the current directory.
sudo cp -r /vagrant/samplepage/* /var/www/html/ - This command copies all files and directories inside the /vagrant/samplepage/ directory to the /var/www/html/ directory.

I had changed my IP address from 192.168.56.18 to 192.168.56.19 when I encountered an error that says: 'The specified host network collides with a non-hostonly network! This will cause your specified IP to be inaccessible. Please change the IP or name of your host only network so that it no longer matches that of a bridged or non-hostonly network.' You do not have to do this excerpt you had the same issue when trying to vagrant up.

If you've made it this far, you should be proud of your accomplishments. You may view the demo web page by clicking here.

The next step is to automate this process so we don't have to manually provision the web server every time we execute 'vagrant up'.

Vagrant Automation

In this section, we'll automate the entire process of setting up a virtual machine, installing a web server, and replacing the default Nginx web page with our actual web page. When we execute vagrant up, our VM and Nginx web server will be provisioned automatically. To do this, we will write a bash script that will launch our virtual machine automatically.

Create a new file called nginx.sh and add the following code to it:



# installing nginx and copying file
apt update
apt install nginx -y
cp -r /vagrant/samplepage/* /var/www/html/

#starting nginx web server
systemctl start nginx
systemctl enable nginx
systemctl restart nginx

Then, in your Vagrantfile, add the following code:



web01.vm.provision "shell", path: "nginx.sh"

This code tells Vagrantfile to run a shell script named "nginx.sh" as part of its setup process.

Validate your Vagrantfile

To check that our Vagrantfile works as expected, we will validate it with



vagrant validate

This command should be executed outside of the ssh terminal.
You should see an output like: “Vagrantfile validated successfully.”

Run vagrant destroy to destroy the existing machine and vagrant up to start the VM with the automated configuration.

Great job! You can now view your web page on the browser using the same IP address you specified in the Vagrantfile.

Conclusion

To summarize, you’ve learned how to create a virtual machine and install Nginx on it. Provision a VM that runs a web server both manually and automatically. If you enjoy DevOps and Cloud computing tutorials, please hit the follow button and stop by frequently.

Docker Terminologies

Roseline Bassey — Sat, 15 Oct 2022 06:41:02 +0000

There's a good chance your first attempt at learning or using a new technology will be tough. This could happen if you’re not familiar with most terms or concepts. Technology such as Docker is an example of this. If you're new to it, its terms may seem confusing.

For instance, if I were to explain Docker and containers to you, I would say: "Docker is a containerization platform that enables developers to create, deploy, and run applications in containers." "A container is a virtual environment that contains all the files and dependencies an application needs to run."

In the explanations, terms such as "containerization," "containers," "virtual environment," and "dependencies" might make it difficult for a new user to understand.

Because of this, it's helpful to understand some essential Docker terms if you're a new user. Your understanding of these terms will help reduce the time spent learning Docker. This blog post will cover some of the most frequently used Docker terminologies.

Docker Terminologies

Every technology has its terms and concepts that are peculiar and Docker is not an exception. Docker has its own set of terminologies that are used by its users. We'll take a look at some of these terms in this part of the blog post.

The following are some Docker terms:

Docker Host

A Docker host is a computer on which Docker Desktop runs. It is a physical machine just like your laptop or a virtual machine. You need a Docker host to run Docker containers. All containers on the host machine share the same portion of the host kernel, which, therefore, makes all containers run in isolation from each other.

Docker Desktop

Docker Desktop is a Docker development environment. It is available for Mac, Windows, and Linux platforms. Docker Desktop includes Docker Engine, Docker CLI client, Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper.

Docker client

The Docker Client is the command line interface that you use to interact with Docker. It communicates with the Docker daemon via a REST API. This communication is carried out on your terminal via your operating system. It sends requests through commands such as “pull”, “create”, and “stop” to dockerd which responds in return. Docker Client can interact with Docker daemon available on a physical or virtual machine.

Docker Daemon

The Docker daemon is installed along with the Docker desktop. It is responsible for the building, running, and distributing of Docker containers. Docker demon consistently listens for API requests from the Docker client to respond to. It manages Docker objects such as networks, storage, containers, and images.

Docker image

A Docker image is an immutable (cannot be changed) file that includes everything needed to run an application. It is an instance or snapshot of a Docker container that can be used to create new containers. Docker images can be hosted as files on a private or public registry, such as Docker Hub. Typically, an image is made up of several layers - the base layer and a layer of dependencies. Docker Images are created using a Dockerfile.

Dockerfile

A Dockerfile is a text file that contains instructions for building a Docker image. These instructions are written in a language called YAML, which stands for Yet Another Markup Language. It contains all the commands that can be used to create a container. A Dockerfile is a text file that contains all the commands needed to build a Docker image.

Docker Compose

Docker Compose is a tool for defining and running multi-container Docker applications. With Docker Compose, you can specify the services and configurations in a single YAML file that your application requires to run. Using Docker Compose you can easily spin everything up or down with a single command.

Docker Swarm Mode

Docker Swarm mode is a tool for orchestrating and managing Docker containers. It is integrated with Docker, so no additional installation is required.

DockerHub

This is a repository for Docker images. It is a cloud-based service that allows you to push and pull images. It is also a great place to find ready-made images for your applications.

Docker Volumes

These are used to persist data generated by a container. Volumes are stored on the Docker host and are not part of the container image.

Docker Server

Docker server is the heart of the Docker platform. It is responsible for managing and running Docker containers.

Local Deployment

This is the process of installing and running an application on a local machine. In relation to Docker, it refers to the process of installing and running Docker locally.

Production:

The process of installing and running an application in an environment that is used by end users.
Production deployments are used for live applications.

Docker Network

This is a type of network that is created by the Docker daemon and used by containers to communicate with each other.

Orchestrator

An orchestrator is a tool or software that is used to manage a group of Docker containers. Two popular ones are Docker Swarm and Kubernetes.

Cluster

A group of machines that are used to run containers.

Namespace

A way to divide a cluster into multiple virtual clusters.

Service

A service is a group of containers that share the same image and provide the same functionality. Services are typically used to deploy and scale applications.

Repository

A repository is a collection of Docker images. Docker Hub is a popular repository that offers a wide variety of images.

Tag

A tag is a label that is applied to a Docker image. Tags are used to identify images and can be used to specify versions or variants of an image

Build

This is the process of creating a Docker image from a Dockerfile.

conclusion

The blog post explained some Docker terms commonly used. Additionally,

Technical Writer's Toolkit.

Roseline Bassey — Fri, 14 Oct 2022 11:23:48 +0000

If you’re new to creating technical content, you'll find that structuring your content in a way that's accessible and communicative might be challenging. You may be wondering what tools you should use as a technical writer.
The following are 10 content creation tools that'll help you create engaging content as a technical content creator:

Madcap Flare
Camtasia
Sangit
Sphinx
Grammarly...

The complete list of tools to add to your toolkit as a technical writer can be found here: https://aviyel.com/post/3800/10-content-creation-tools-every...

hacktoberfest2022 x Aviyel

Basic Docker Commands for Beginners.

Roseline Bassey — Mon, 11 Jul 2022 16:18:18 +0000

The first part of this article introduces you to Docker, monolithic and microservice architecture, virtual environment, and containers.

With this general knowledge of Docker and containers, it's time to jump right into running applications in containers.

If you're just getting started with Docker, you'll learn some practical Docker commands in this post that will let you pull and run a Docker image locally, start and stop a container, list all currently running containers, and debug containers.

This blog post also provides some background information that will clarify the precise difference between a container and a Docker image.

To get the most out of this post, ensure to practice each step to get a feel for working with applications in Docker.

Prerequisites

Install Docker
Before you begin you should have Docker installed and running. If you haven’t, please see Docker’s official documentation on how to install Docker and make sure to install the stable version. Docker can be installed on Linux, Windows, and macOS.
Terminal
Launch your preferred terminal, which could be Terminal on Mac, a Bash shell on Linux, or PowerShell on Windows.
Create a DockerHub Account
DockerHub is a public registry where applications are published. DockerHub is like GitHub but for Docker images.
Internet connection
You'll need an internet connection for some commands to execute.

The Difference Between Docker image and Container

Docker image is simply a file that represents a container. For example, when you package an application with all its dependencies and push it to DockerHub or your private registry, the file in the registry is an image that represents your container.

A container can be viewed as a "box". In this box is an application that is packaged with its dependencies needed to run the application.

This application has its distinct virtual environment- the hostname, disk, and IP address, which is managed by Docker. The application inside the box cannot have any interaction with the outside environment.

The box is called the container because it contains the application with its dependencies. Containers share the host operating system (OS), CPU, and memory.

A container is an instance of a Docker image and a running environment of an image.

To understand exactly the difference between container and image let's practice some commands.

This tutorial uses redis for illustration. You could choose to use a different image or container and it'll still work the same.

docker pull

Usage: docker pull IMAGE NAME

docker pull is used to download or pull an image from the repository to your local machine. To access an image locally you must pull it first.

let's pull a redis image from DockerHub to our local machine.

Search for Redis in the search bar and click on the image.

In your terminal, run the following command: docker pull redis

The image is pulled, downloaded, and extracted by Docker when you run the command.

The application package consists of six layers coupled together to run the application.

Note: The latest tag is automatically pulled when you pull an image without specifying a tag. A tag is the same as a version.

docker images

To ensure that the image has been downloaded, run the following command in your terminal docker images. This will list all existing images.

In the above, there's just one image with the REPOSITORY-redis, TAG-latest, image ID, when it was CREATED, and SIZE of the application.

Note: You could specify a version or tag if you don't want Docker to download the default tag.

Tag

You could specify the image tag by running the command docker pull redis:10.1.
10.1 is the version specified. Remember the version is always followed after a semicolon.

Now, you need to get redis running to make it reachable by your application.

docker run

Usage: docker run IMAGE NAME

The run command is used to create a container of an image. The first time you use the run command, Docker informs you that the image doesn't exist locally so it'll search for it on DockerHub, pulls and starts the image.

If the image already exists locally, docker goes ahead to run a container of the image.

But if the image doesn't exist in DockerHub or your local machine, you'll get no error message from Docker.

At the point at which the image is running, the image is no more regarded as an image but as a container.

To run the just downloaded image, use docker run redis. It'll run a container called redis.

In the above image, the docker run command starts the redis image in a container.

docker run -d

Usage: docker run [OPTIONS] IMAGE NAME

The -d is one of several docker run options. It is used to run a container in a detached mood.

docker ps

The docker ps command lists all running containers. This command allows you to track your container’s progress. If you ever get an empty list from running the command, ensure that your container is running.

Note: You could use a separate terminal window to run the container and another for the docker ps command.

docker ps -a

Usage: docker ps [OPTIONS]

Several options could be used with the docker ps command such as -a, -f, -s, etc. For instance, the -a option lists all the exited and running containers. This allows you to track the status of a container. Run the command docker ps -a to view all your containers.

This image shows all containers in their current status.

docker stop

Usage: docker stop CONTAINER ID

Containers can be terminated by using the stop command. There are several reasons why you may want to stop a container.

An error or a crash might require you to stop a container. You'll need the ID of the container that you want to stop.
In your terminal run docker stop "Container ID"

docker start

Usage: docker start CONTAINER ID

Using this command, you can restart a stopped container. You can do this by running the docker start "container ID" command.

The container specified will be started with this command.

Working With Containers

The next part of this blog post will walk you through the steps and basic commands of working with a running container. For your application to connect to the container, the container must be reachable.

To connect the container to your application, you'll need to bind the host port to the container’s port. The diagram below illustrates how host binding works.

A host port is a port on your computer that your container binds to. Whereas, a container's port is a port on which the container runs and is used to access the services or dependencies inside the container.

For instance, the port of the container below is 6379/tcp

You must first specify the host port before binding the port of the container to it

Execute the following command in your terminal: docker run -p8080:6379 redis

The -p flag in the command means port.

Note: Before executing the command, make sure the container has been stopped.

To check that the host and the container's port have been connected, let's run the docker ps command.

In the image above the host’s port 0.0.0.0:8080 has been connected to the container’s port 6379/tcp.

docker logs

Usage: docker logs [OPTIONS] CONTAINER ID

You can look through a container's logs using this command. It is utilized to debug or troubleshoot containers.

Note: This command is only functional for containers that are started with the json-file or journald logging driver. -- Docker

docker exec

Usage: docker exec [OPTIONS] CONTAINER ID /bin/bash

This command is used to access a container's terminal. In the container's terminal, you could navigate directories and issue commands just like on your command line.

Run docker exec -it "container ID" /bin/bash, for instance, to access the redis container terminal.

The -it flag means interactive and indicates that you would like to assess the terminal inside the container.

In the first line, we executed the command and got access to the root directory. In the second line, the pwd command lists our working directory. We navigate to the directory in line 3 and use the ls command in line 4 to list all the directories inside the root directory -- /data.

docker rm

Usage: docker rm [OPTIONS] CONTAINER ID

If you want to clean up or remove containers or application packages after following the exercises, you can run this command: docker rm -f CONTAINER ID

Summary

In this blog post, you’ve practiced working with basic Docker commands such as pull, run – which pulls and launches an image, stop, start, logs, exec, rm, etc. You learned how to bind a host and container ports as well as the difference between container and Docker image.

In addition to the Docker commands that were covered in this article, there are many others that you might want to look into. If you'd like to learn more about the Docker command line, please use the link in the resource section.

Resources:

Introducing Docker Concepts, Containers and More.

How to Use the Docker command line

Tech Industry is Deep. Find Your Path and Stick With It.

Roseline Bassey — Sun, 10 Jul 2022 14:05:39 +0000

This tech industry is so deep. Simply find your path and stick around with it.

You'll be shocked at how much you've grown when you reflect on your progress over the next 12 months.

Hey, let's get to hear about your journey.

if you've just begun your tech journey, tell me, how has it been so far?

To the experienced techies, what advice would you give to anyone just starting in tech?

Introducing Docker Concepts, Containers, and more

Roseline Bassey — Sat, 02 Jul 2022 20:33:50 +0000

Containerization has rapidly gained popularity as a game-changing technology, enabling developers to package applications and their dependencies into self-contained units known as containers. Docker, with its user-friendly interface and powerful features, has emerged as the go-to solution for harnessing the full potential of containerization.

Throughout this article, we will demystify the core concepts of containerization, shed light on the remarkable benefits it offers, and zoom in on Docker's architecture and key components. We will delve into the difference between Docker and virtual machines, and containers themselves, where applications run in isolation, providing enhanced scalability, flexibility, and efficiency.
Before then, let's learn about Docker.

What is Docker?

Docker is an open-source containerization platform used to build, test, manage, and deploy applications in a cloud-based environment.

Docker provides a way to package an application into a "container," which can be run from any machine that has the Docker software installed. It makes it easy for you to run an application across different machines or environments.

As organizations shift toward cloud-native and hybrid development, Docker is rapidly becoming the preferred tool for building and sharing containerized apps.

Origin of Docker

Docker was first released in 2013 and has since become one of the most popular tools for developers. The idea for Docker came about when Solomon Hykes, the creator of Docker, was working on a project at dotCloud, a cloud hosting provider.

The project required him to use many different virtual machines, each with different versions of the same software. This was difficult to manage and ended up being very time-consuming.

To make his life easier, Solomon created a tool that would enable him to package an application and its dependencies into a single container.

This way, he could easily move the application between different machines without having to worry about compatibility issues.

Docker makes it easy for developers to create, deploy, and run applications in a consistent environment, without the need to worry about differences between machines.

Docker has since gained popularity and saw more support from commercial companies such as Amazon and Microsoft, further bolstering its credibility in the container management market.

How Did it Become so Popular?

Docker became popular because it offered a way to package an application with all its dependencies into a “container”.

The containers are portable and can be run on any machine that has the Docker runtime installed. It also provided a way to share these containers using Docker Hub, which is like GitHub but for Docker images.

Problem Before Docker

In the past, developing and deploying software applications has been a time-consuming and error-prone process.
This is because each application has its dependencies and configurations, which can often conflict with other applications.

Traditionally, applications are built on a type of architecture called monolithic. In monolithic architecture, all components of an application are packaged together in one large program.

Each line of code, libraries, and dependencies is connected to one another–meaning that each layer of the application is built on top of each other which often creates a series of problems.

In traditional methods, code is developed in a specific computing environment which, when transferred to a new location, often results in bugs and errors.

One of the most likely problems developers complain about is the "it works on my machine" problem. With Docker, developers can collaborate on projects without fear of breaking each other's code.

Imagine you are part of a developer's team and you are working on a Javascript application that requires PostgreSQL and Redis for messaging.

You'll need to install these services directly on your operating system. For any developer within your team to deploy the app, they must install binaries of these services, configure them, and run them locally.

Installation may look very different depending on which operating system is used and may involve many steps that need to be performed, and perhaps something could turn out wrong.

This process can be frustrating, and costly, and you may have some difficulty scaling and deploying applications.

Deploying and packaging apps in a reliable and repeatable way has always been a pain point.

According to Rob Vettor and Steve “ardalis” in , Architecting Cloud-Native .NET Apps for Azure, some of the problems you could face using this architecture include:

The app has become so overwhelmingly complicated that no single person understands it.

You fear making changes - each change has unintended and costly side effects.

New features/fixes become tricky, time-consuming, and expensive to implement.

Each release becomes as small as possible and requires the full deployment of the entire application.

One unstable component can crash the entire system.

New technologies and frameworks aren’t an option.

Its difficult to implement agile delivery methodologies.

Architectural erosion sets in as the code base deteriorates with never-ending “quick fixes.”

Finally, the consultants come in and tell you to rewrite it.

Due to this, many organizations have shifted to adopting a cloud-native approach to building containerized applications.

Containerization

Containerization eliminates these problems by bundling the application code together with the related configuration files and dependencies, making it easy to deploy and run in any environment.

Containerization is a type of virtualization that allows you to run multiple applications on a single server. This can be extremely beneficial for businesses, as it can help to save on server costs and increase efficiency.

Containerization has many benefits, but one of the most important is that it eliminates the "it works on my machine" problem.

This is because the container includes everything needed to run the application, so it will work the same in any environment. This is a huge benefit for software developers, as it makes it much easier to develop and test applications.

If you're looking for a way to improve the development and deployment of your software, then containerization is a great option to consider.

Container

Containers help simplify the process of deploying applications. Containers allow you to isolate each component or layer of an application from each other. It allows you to run different applications on the same host without them interfering with each other.

Image source: Docker

In the diagram above, each application(container) is isolated from other containers managed by Docker in your host operating system.

Hence, the breakdown of one container does not affect the performance of another.

Benefits of Containers.

Some of the key benefits of containerization include:

Containers are lighter and require fewer resources thereby, making them more efficient to run.
Containers can be moved easily between environments, making them ideal for development and testing.
Isolation between containers prevents one application from affecting another, improving stability and security.
Increased security, since container isolation prevents malicious code from infecting the underlying system.
Improved performance, since containers do not need to be booted every time they are run.
Easy to Use: Containerization is easy to set up and use, which can save you time and money.
Scalable: You can easily scale your containerized applications to meet the demands of your business.
Portable: You can move containerized applications between servers, which makes it easy to maintain and update them.

Overall, containerization provides a more efficient and robust way to deploy applications.

Monolithic

Monolithic software architecture is one in which all components are tightly coupled and interdependent. This type of architecture has been traditionally used for large-scale applications.

The main disadvantage of a monolithic architecture is that it can be more difficult to maintain and modify.

Because all components are tightly coupled, a change to one component can potentially break other components. In addition, monolithic architectures can be more difficult to scale than other architectures.

Microservices

Microservices refers to the practice by which applications are broken down into smaller pieces called “microservices” so they can be built individually and then wired together when needed.
This allows for greater flexibility and scalability.

The difference between Docker and virtual machines

Docker and virtual machines are both popular ways to organize and isolate applications.

Image source: Medium

Docker is a containerization platform that allows you to create and run isolated applications. With Docker, you can bundle your application into containers.

Containers are lighter than virtual machines and can be spun up more quickly. They're also more portable since they can be deployed on any machine that supports Docker.

Virtual machines are full-fledged operating systems that are run on top of a hypervisor. Virtual machines are also less portable than containers since they require specific hardware configurations.

They're also heavier and take longer to spin up. They are isolated from each other, so an attacker who compromises one virtual machine cannot access other virtual machines on the same host.

Summary:

Our discussion covered the basics that can help you get started with Docker, but you also learned about Docker as a whole, why Docker was created, and the problems it addresses.

You also learned about containerization and how it makes it easier to deploy apps from desktops to the cloud. You learned about the benefits of using containers in app development.

The difference between a virtual machine and Docker was also discussed, as well as monolithic and microservices.

Learn more about Docker commands you'll frequently used as a beginner.

The following resources will help you learn more about Docker:

Resources:

Introduction to Container By Red Hat

TechWorld with Nana - Docker Tutorial for Beginners

Docker Tutorial for Beginners - What is Docker? Introduction to Containers

Programming with Mosh - Docker Tutorial for Beginners

Want to Be a Programmer?

Roseline Bassey — Tue, 15 Mar 2022 15:53:44 +0000

Most likely, you've heard your friends, family, or social media buddies talk about programming and its benefits. Alternatively, perhaps you are interested in working in a company such as Google, Amazon, Meta, etc., and would like to learn how to program so you can get your dream job with them.

This blog post would provide you with an understanding of the basics of programming, as well as how you can start learning this valuable skill. I hope that after reading this post, you’ll be excited to start your programming journey!

What is Programming?
Programming is the process of writing instructions for a computer to follow. These instructions tell the computer how to carry out a task. For example, when you create a new Amazon account, you go through a set of instructions written by programmers.

This is made possible by the programming code that tells the computer what to do. So, writing these instructions is called programming. They are written by programmers.

Who is a Programmer?
A programmer is somebody who writes code, or specific sets of instructions, that tell a computer what to do. They might create and design websites, develop desktop programs, build mobile apps, develop video games, create Artificial Intelligence algorithms, or perform statistical analysis - just to name a few possibilities. In other words, they make the computer do what they want it to.

For example, they might write instructions that say ‘add the two numbers in cell A1 and cell B1, and put the answer in cell C1’. The computer will then follow those instructions and do exactly what the programmer has told it to do. In a sense, a programmer is like an artist who creates things with code. Programmers might work alone or in teams. They could be employed by companies or organizations that need their skills, or they could be self-employed.

The Language of the Computer
Just like you and I use language as a means of communicating our ideas, expressing our emotions and thoughts. Computers also make use of language to communicate. The computer language is defined as the syntax used to write specific applications. Its language is represented as binary digits 0’s and 1’s. The computer language can be classified into three categories:

High-level Language:
This is the language that is commonly understood by humans. A high-level language contains symbols and words familiar to humans. This kind of language is used by programmers in writing programs. Examples of high-level languages include BASIC, COBOL, Pascal, and C++.

Assembly language:
This is a low-level computer programming language that makes use of mnemonic codes (Abbreviation of a longer name) to represent instructions. Examples of assembly languages include 8086, 8085, 8051, and PIC Microcontrollers.

Machine language:
This is a low-level computer programming language that uses binary numbers to represent instructions. Instructions are represented in 0’s and 1’s that the computer understands and responds accordingly. For example, your first line of code could be a piece of code that displays “Hello World” on your computer screen. The only reason why your computer responded with “Hello World” text is that the compiler converts the programs to binary codes known as machine language.

An example of machine language for the text “Hello World” is interpreted this way:

           01001000 0110101 01101100 01101100
           01101111 00100000 01010111 01101111
           01110010 01101100 01100100.

What Exactly is a Programming Language?
Programming language is a language that is understood by a computer. By receiving instructions written in the programming language, the computer acts, behaves, and executes according to the instructions.

Programming languages come in a variety of types, and each has a specific function. Before you start programming, it's important to understand how different programming languages operate. Moreover, it is important to choose a language that matches your vision or goals.

Types of Programming Language:
Just like human language is diverse from nation to nation or even within a nation, so is the programming language. There are different types of programming languages available today. Some of them make it easy to read and write code while others help programmers in solving complex problems. That being said, let’s take a look at some of the most popular programming languages:
JavaScript
Java
Python
C++ etc.

How to Learn to Code
Learning programming languages is similar to learning foreign languages. While acquiring your first language may seem easy with no or less amount of effort, a second language requires you to pay attention to the language rules. For example, to learn how to be proficient in a given language one needs to pay keen attention to the grammatical rules or conventions that guide the language.

So, learning to code is not far from this reality. Let's say for example you’re learning to write in JavaScript. You'll need to learn and get familiar with the syntax, its conventions, rules, etc. That way you’ll be able to write codes in JavaScript.

What Programming Language Should you Learn?
One of the most common questions asked by prospective programmers is what is the best programming language to learn? There is no absolute “best” language; each language has its strengths and weaknesses. Before choosing a programming language you should consider answering the following questions:

Do you intend to build web apps?
Do you want to develop Android apps or iOS apps?
Do you have an eye for video games?
Are you good at arranging data structures?
Are you fascinated by building stuff with AI?

Considering your answers to these questions you should have a clear guide to the type of languages required in your chosen field. However, it’s advisable at this point in your career that you focus on mastering a particular programming language. Don’t make the mistake of jumping from one language to another. Do you know why? No company pays you for knowing all the programming languages in the world, they rather pay you for what problem you’re able to solve with a specific language. Therefore, choosing a language is dependent on your career path.

Starting with HTML and CSS
CSS and HTML are technically not programming languages, but they are an excellent place to begin when learning about how programming works.

What is HTML?
HTML is an acronym that stands for HyperText Markup Language and the latest version is HTML5. It defines how the web page contents can be displayed on different devices such as computers, tablets, phones, and other portable devices. HTML describes the structure of a Web page.

It is the skeleton to which you build your page's content. It describes how text, links, and images will be formatted and displayed on a webpage. It consists of several elements and each element tells the browser how to display the content.

The Basic Structure of an HTML Document

Typically, an HTML document consists of 5 elements:

1.<!DOCTYPE html>
The DOCTYPE declaration is used to specify which version of HTML the page is written on.

<html>
This is the root element of an HTML page.
<head>
The head element contains meta information of the page that isn’t displayed directly on the Web page. <meta> element provides additional information such as page keywords, page description, and the author(s) of a web document.
<title>My New HTML Page</title>
The title element defines the title of the page. It is displayed in a Web browser’s title bar.
<body>
The body element contains Web page content such as texts, videos, images, links, etc. that are visible.

HTML Elements and Attributes
HTML tags or elements, and attributes are the building blocks of HTML and are used to create dynamic and responsive web pages.

Elements
An element consists of an opening and closing tag with the content inserted in between. It is enclosed by angle brackets but with a forward slash inserted before the end tag. For example, the <p> element is used to create a paragraph.
<p>My first paragraph.</p>

Attributes
An attribute provides additional information about an element. Attributes are written within the opening tag. It is made up of a name and a value. The value of an attribute is inserted within quotation marks like in the image below.

File Naming Conventions
While there is no standard way to name your HTML and CSS files, there is a standard extension suffix that should follow your file name. HTML files must end in .html while CSS files must end in .css just like in the image below.

What is CSS?
CSS, or Cascading Style Sheets, is a common language used to define the style of a page. It defines the visual appearance of a site. CSS is used by your browser to design the layout and style of your web page.

Understanding CSS Style Guide: Inline, and External Style Guide
The CSS style guide defines how CSS elements create different layouts on any web page or platform.

These are two types of CSS style guides: inline, and external.
Inline:
Inline style means that the styling information is contained within your HTML source code itself. This approach is easy for most people to understand and maintain, but can lead to conflicting styles within your source code when developers work on different pages in a website.

External:
External style refers to styles that are located in an external file referred to as an external style sheet (or .css file for short). These styles can usually be modified without affecting other files.

Tools You Need to Start Programming
To start writing codes you’ll need a text editor. There are lots of them out there but I’ll recommend only a few.

Atom: This is a free desktop text editor that allows you to work with Git and GitHub directly from Atom. It’s one of the best text editors.

Visual Studio Code: This is a code editor optimized for building and debugging modern web and cloud applications. It is free and easy to use. It has tons of plugins available to make work easier for you. The user interface is simple to understand and you’ll get used to it in no time.

Notepad++: Notepad++ is a free source code editor that supports several languages. It runs in the MS Windows environment.

Aside from a text editor, you’ll need a browser too. Browsers help in reading and interpreting your codes. The following browsers are recommendable; Chrome, Firefox, Microsoft Edge, etc.

You’ll also need a good working laptop and an internet connection.

Where do I learn to program?
There are many ways to learn how to program. You can take courses at your local college or university, or you can take online courses on sites like Coursera, Udacity, Udemy, FreeCodeCamp, or Pluralsight. You can also teach yourself by reading books or watching tutorials on YouTube.

Conclusion
Overall, programming is a high-paying career that requires patience, dedication, and a great deal of attention to detail.
It does not matter from which background you come, if you love learning new things and are willing to stay positive, you can succeed.

DEV Community: Roseline Bassey

Android App: Instrumented and Unit Tests Automation Using CircleCI

Instrumentation Testing

Unit Testing

CircleCI

Unit Testing and Instrumentation Testing in CI/CD

Setting up Automated Android Testing on CircleCI

Create a circleci.yml File

Running Unit Test

Running Instrumentation Tests

Using the No-orb Example

Using Android Orb Example

How to Setup CircleCI

Recap

How to Set Up an Nginx Web Server in Ubuntu Virtual Machine Using Vagrant

Vagrant

VirtualBox

Ubuntu

NGINX

Before You Dive In

Creating an Ubuntu Virtual Machine Using Vagrant

Accessing Nginx Web Server on Browser

Nginx Demo Page

Replace the Default Page with your Website

Vagrant Automation

Validate your Vagrantfile

Conclusion

Docker Terminologies

Docker Terminologies

Docker Host

Docker Desktop

Docker client

Docker Daemon

Docker image

Dockerfile

Docker Compose

Docker Swarm Mode

DockerHub

Docker Volumes

Docker Server

Local Deployment

Production:

Docker Network

Orchestrator

Cluster

Namespace

Service

Repository

Tag

Build

conclusion

Technical Writer's Toolkit.

hacktoberfest2022 x Aviyel

Basic Docker Commands for Beginners.

Prerequisites

The Difference Between Docker image and Container

docker pull

docker images

Tag

docker run

docker run -d

docker ps

docker ps -a

docker stop

docker start

Working With Containers

docker logs

docker exec

docker rm

Summary

Resources:

Tech Industry is Deep. Find Your Path and Stick With It.

Introducing Docker Concepts, Containers, and more

What is Docker?

Origin of Docker

How Did it Become so Popular?

Problem Before Docker

Containerization

Container

Benefits of Containers.

Create a `circleci.yml` File