BuildX

buildx

Dependency Injection With Dagger 2: What Is It, Key Concepts, and More

ডিপেনডেন্সি ইনজেকশন উইথ ড্যাগার 2: এটি কী, মূল ধারণা এবং আরও অনেক কিছু

Abhängigkeitsinjektion mit Dagger 2: Was ist das, Schlüsselkonzepte und mehr

Inyección de dependencia con Dagger 2: qué es, conceptos clave y más

Injection de dépendances avec Dagger 2 : qu'est-ce que c'est, concepts clés et plus encore

डैगर 2 के साथ निर्भरता इंजेक्शन: यह क्या है, मुख्य अवधारणाएँ, और अधिक

Dagger 2 による依存性注入: その概要、主要な概念など

Dagger 2를 사용한 종속성 주입: 그것이 무엇이고, 핵심 개념 및 기타

Injeção de dependência com Dagger 2: o que é, conceitos-chave e muito mais

Внедрение зависимостей с помощью Dagger 2: что это такое, основные понятия и многое другое

Dagger 2 ile Bağımlılık Enjeksiyonu: Nedir, Temel Kavramlar ve Daha Fazlası

Dependency Injection Với Dagger 2: Nó Là Gì, Các Khái Niệm Chính Và Nhiều Hơn Nữa

使用 Dagger 2 进行依赖注入：它是什么、关键概念等等

Many sales folks say by Dale Carnegie is a go-to book if you want to get good at selling stuff. I read it when I was 14, but I only remember that we love the sound of our name. How to Win Friends and Influence People So I thought I’d attempt my version of HTWFAIP because people often ask me how I make friends so easily (I know I sound like an Instagram influencer about to sell you some sketchy product, but really, people do ask 😂). Yet, being friendly and likable was a skill I had to develop. Back in one of my first jobs, my boss told me I had a “resting bitch face.” I think it should be called a “resting Eastern European face” (REEF for short 😁). I see it a lot after moving back home after 12 years abroad. The typical explanation is that a colder climate makes us ‘colder people’, but I think it has a lot to do with the long history of russian occupation, but I derail. Following the comment of my manager, psychology studies and life experiences, I’ve decided to intentionally work on my personality. Over the years, I’ve figured out some tricks to make myself more likable and good at social stuff. Now, I can’t turn it off - it’s a part of my identity. Human psychology by the CIA The CIA had to figure out how human nature works to carry out successful espionage. I already shared a full scope of what I learned in this , so this is a quick reminder relevant to our topic. article Humans have three lives. (how we want to appear to others, like an Instagram feed). Public life (what your closest confidants know about you. Like your feet smell). Private life (often, these are thoughts that live in a dark part of our psyche that we’re afraid to share for fear of rejection/judgment, like having a mistress). Secret life The CIA builds trust with a target by methodically earning trust, aka getting into someone’s secret life. To the target, it reads as I revealed so getting sensitive info about the target’s government becomes much easier. the worst parts of me and they’re still here, I haven’t been rejected, therefore I trust this person, Now, the 3 lives principle applies to friendships. I trust and, therefore, like my close friends more than I do acquaintances because close friends see all parts of me and still stick around. Closeness correlates with likeability. But closeness also correlates with likeability. perceived Rule #1 for building connections - TRUST. Building rapport Building any relationship requires time. But some hacks make you more likable to people who don’t yet know you. The caveat here is genuineness - people smell a fake a mile away (unless they’re dealing with a CIA spy 😉). You have to be genuinely interested in other people. I think I’m successful at connecting with people because I’m sincerely interested in them. What is their inner life like? What are they passionate about? What do they struggle with? How do they feel? Why did they choose the particular career path? Rule #2 - be genuine or get out of the conversation because nobody likes a fake. Ways to build rapport Mirroring: Subtly mimic the person’s body language, speech patterns, and gestures to create a subconscious sense of familiarity and trust. Let’s say I’m sitting cross-legged - you should cross your legs too. If the person lowers their voice, you should follow. Emotional Vulnerability: Share personal stories or vulnerabilities to encourage reciprocity and strike up the connection. Volunteer emotional vulnerability as a way to gain trust and show you want to go beyond the public life persona. Do make anything up. not For example, at a recent party, I sat next to a stranger and said, ‘I always feel so awkward at parties where I don’t know anyone - I feel a bit of anxiety.’ That was both a true and relatable experience, so the person could open up as well, and we launched into a conversation where they very quickly opened up their private life info as well as volunteered a spare room if I’m ever in their neck of the woods. Active Listening: Pay close attention to the person’s words, emotions, and non-verbal cues, demonstrating genuine interest and understanding. The common mistake people make in conversations is that they’re too caught up in their own thoughts, planning their answers instead of truly listening to the other person. You can avoid this by practicing mirroring and labeling techniques during the conversation. I first came across these ideas in a former FBI hostage negotiator work. If they worked for him, they’d work for you, too 😉 Chris Voss’ a technique where you repeat back the last 1–3 words of what someone told you. Mirroring (yes again, but a different kind) - For example: Someone: ‘I was late for work again!’ You: ‘Late again?’ (An open-ended remark unconsciously inviting the other person to expand). Casually repeating the words back helps you stay present and truly listen, making the other person feel heard, thus building rapport. This openness leads to greater liking and trust between people. is another technique that encourages you to listen make the other party feel recognized. You could call it a verbal observation/recognition. Labeling and For example: Someone ‘I enjoy spending quality time with my friends’ You (Spotting patterns or making inferences makes the other person feel heard). ‘It sounds like you’re someone who values friendships!’ Similarly to mirroring, don’t overuse labels. Remember, these techniques are here to help you be present in the conversation. It’s a chat, not a therapy session. Asking Questions: Use open-ended questions to encourage the person to share more about themselves and their experiences. Avoid yes or no questions, especially with shy or socially anxious people, and opt for open-ended ones to encourage sharing. This approach helps the conversation flow more naturally, giving you more to build on. Finding Common Ground: Identify shared interests, experiences, or values to establish commonality and foster a sense of camaraderie. This is easy - look at the context you’re in and come up with conversation topics based on that. I was at a friend’s gathering recently with both friends and strangers. Instead of the usual ‘How do you know so-and-so?’ to break the ice, I recognized someone I often see at my favorite coffee shop, always deep in phone convos. I approached them with, “Hey, I've seen you at Cafe X, but you're always on the phone, so we never get a chance to chat.” They found it amusing, and we instantly connected. Acknowledge the person in front of you, or see them, as I call it. really I realized that we often interact with our idea of a person or their public life persona rather than with the individuals themselves, especially in public settings. As an experiment, I decided to move beyond the routine “hi, how are you” at coffee shops and restaurants where I play the social role of a customer and the server plays the role of the server. I made an effort to genuinely notice and acknowledge them, perhaps with a compliment or a unique question about their day. These small acts of genuine interest made them light up, feeling valued as individuals. Upgrades or free stuff was a nice byproduct of this experiment:) Principle #3 - humans crave being seen, acknowledged… to matter. Bonus tips If you only get one takeaway from this article - people talking about themselves. Sharing personal stories makes us feel recognized and heard. If you can provide that space for someone, you’re golden. LOVE Another benefit of someone talking about themselves and opening up to you is that it makes them trust you more. The more they talk, the more they trust you. The person asking the questions is always in control of the conversation. Parents adore it when you connect with their kids. Doing so can win you a lot of favor. But remember, you’ve got to be genuine. Kids are great at detecting insincerity and can spot someone faking it from a mile away. Feeling social anxiety is normal and something I still face, but I've found a helpful mantra: “No one's better than me, and I'm no better than anybody else.” I used to repeat this to myself multiple times before social events. Focus on your surroundings and the person you’re with. Most people are preoccupied with their thoughts, so you'll stand out by complimenting or sharing an observation. You have to like yourself more than spending time with people you don’t like. Wrap up I’m a bit worried this advice might sound contrived because it’s hard to put into words something that’s become second nature. Applying these social practices initially felt awkward, much like learning to drive. But just as driving becomes automatic over time, these practices have become ingrained in me. I come across as natural and sincere, and that’s because I am. Remember: Be genuinely interested in the other person; them. see Be an active listener and avid observer. We are inclined to think and talk of ourselves more, override it. Let the other person shine. Further reading My very first article online was about likeability. Back then, I was coaching men to increase their attractiveness in ways beyond the usual superficial advice. You can find it here. I initially wrote the CIA series in 3 parts, but you can find them in one place on . It’s a good overview of human psychology. HackerNoon The article above is aimed at social interactions. I have a separate article on the topic of building and maintaining friendships . here Photo by on Oveth Martinez Unsplash Also published . here

Building a Reusable Deployment Workflow with Kamal and GitHub Actions

Introduction As web developers, we used to find appropriate hosting for our applications with all the complications of deploying and maintaining them. But now, we live in a new era when cloud providers can make a lot of things for us at almost no cost. As for .NET developers, Microsoft Azure looks most natural choice to host web applications. Docker is another piece of technology that makes it possible to abstract from the platform and environment you are running your application. In this article, I will give a detailed guide on how to create a simple ASP.NET Core web application, create a docker image with your application, and the easiest way to deploy it to Azure. In the end, you will have a good understanding of how to deploy your web application and make it accessible to the whole world. 1. Create ASP.NET Core Web App I’m going to use JetBrains Rider for the purpose of the development in this article. But you can use any tool you want. First, you need to create a new project. Let’s call it simple ‘ ’. webapp After creating a new project, it should look like this: 2. Create a Docker Image Without any changes in the project, we are going to focus on the . Modify it as the following example: Dockerfile FROM mcr.microsoft.com/dotnet/aspnet:6.0 as base
WORKDIR /app
EXPOSE 8080
ENV ASPNETCORE_URLS http://+:8080

FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
COPY . /src
WORKDIR /src
RUN dotnet build "webapp.csproj" -c Release -o /app/build 

FROM build AS publish
RUN dotnet publish "webapp.csproj" -c Release -o /app/publish 

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "webapp.dll"] You need to pay attention to the lines and to be able to connect via HTTP to the docker container. EXPOSE 8080 ENV ASPNETCORE_URLS http://+:8080 Build a docker image from the command line. You need to navigate to the project directory, and execute the following command: webapp DOCKER_BUILDKIT=1 docker buildx build --platform linux/amd64 --tag drmoz/webapp:latest . I’m running it on Mac M1, and I have to specify parameter explicitly to be compatible with Azure deployment. I also have to activate the Docker Buildkit by specifying the parameter and using to be able to build an image for another architecture. --platform DOCKER_BUILDKIT=1 buildx If you are running it on the Intel x86/x64 platform, you can use command without the need to specify parameter and activate . docker build --platform buildx You can tag your image differently, but since I’m going to use Docker Hub, I have to specify my account name: as part of the image tag . drmoz drmoz/webapp:latest When an image is built, you can check if it is present in the Docker by running the following command: docker images It should be on the list: REPOSITORY        TAG         IMAGE ID       CREATED          SIZE      
drmoz/webapp      latest      0cfac748256b   37 minutes ago   216MB Let’s run the docker container to verify that the newly created image works fine. Execute command to start a container: docker run docker run -p 5555:8080 drmoz/webapp:latest Specify the parameter to map the port inside the container to your local machine port. Also, specify the image name to create the container. In my case, it is . -p 8080 5555 drmoz/webapp:latest Now, you can navigate in your browser to see the ASP.NET Core Web App home page. http://localhost:5555 We need to push an image to the . Before that, you must register on the Docker Registry, and create a repository. Click on the ‘ ‘ button on the right corner of the home page. Docker Hub Create repository Specify the field, and keep the repository visibility . Repository Name Public In the command line, you have to log in to the Docker Hub registry: docker login After that, you will be able to push a newly created image to the registry: docker push drmoz/webapp:latest Navigate to the repository, and you will see the information about the image: 3. Create a Web App in Azure Now, we are ready to deploy our ASP.NET Core Web Application to Azure. Let’s log in to the Azure Portal, and create a new resource group. Specify the Resource Group name as ‘ ’, and click the ‘Review + create’ button. webapp-rg On the next screen, just hit the ‘Create’ button. Now, we can create a Web App. Navigate to the ‘Create resource‘ page, and find WebApp. Click the ‘Create’ button. You need to specify the one that we created previously. Also, specify a unique for the Web App. Select ‘Docker Container’ in the field. Later, we will be able to specify which Docker image to use. Resource Group Name Publish Select any suitable options in the section, but I recommend using a tire for test purposes. Navigate to the Docker tab. Pricing plans Free F1 On this tab, select ‘Docker Hub’ in the field. Select ‘Public’ in the field, and specify the value with the name of the image we pushed to Docker Hub. Navigate to the ‘Review + create’ tab. On this tab, click the ‘Create‘ button: Image Source Access Type Image and tag When the new resource is deployed, you will be asked if you would like to navigate to this resource; just do it. You will be able to see information regarding the Web App. Click on the ‘Browse‘ button to open a deployed web application. If everything went correctly, you should see the ASP.NET Core Web App home page similar to the one you saw in your browser by navigating . http://localhost:5555 Enable Continuous Deployment If you navigate to the ‘Deployment Center’ settings and enable ‘Continues deployment’, you will be able to redeploy your image every time you push a new one to the Docker Hub. In that manner, you can make changes to your code, push it to the Docker Hub with a new image, and see changes in minutes in Azure. Azure Web App Troubleshooting To be able to see deployment logs and identify issues, you need to enable saving logs to the file system under the ‘App Service logs’ chapter as follows: When it is done, you can navigate to the ‘Deployment Center’ and see logs as follows: Summary If you reach this point, you managed to create an ASP.NET Core web application; pack it to the Docker image, and deploy it to Azure. Nowadays, technology makes life easier and speeds up the development process. You can see how easily you can deploy your application to the cloud provider and expose it to the whole world, perform some testing, and see the result of your work. Now, you can dive into the details of Azure cloud providers using Microsoft . Also, take a look at the Docker for a deeper understanding of this piece of technology. I hope it might be helpful. documentation documentation

How to Deploy an ASP.NET Core Web App in Azure From Docker Image

ডকার ইমেজ থেকে Azure-এ একটি ASP.NET কোর ওয়েব অ্যাপ কীভাবে স্থাপন করবেন

So stellen Sie eine ASP.NET Core-Webanwendung in Azure über ein Docker-Image bereit

Cómo implementar una aplicación web ASP.NET Core en Azure desde la imagen de Docker

Comment déployer une application Web ASP.NET Core dans Azure à partir de l'image Docker

डॉकर इमेज से Azure में ASP.NET कोर वेब ऐप कैसे तैनात करें

Docker イメージから Azure に ASP.NET Core Web アプリをデプロイする方法

Docker 이미지에서 Azure에 ASP.NET Core 웹앱을 배포하는 방법

Como implantar um aplicativo Web ASP.NET Core no Azure a partir da imagem do Docker

Как развернуть веб-приложение ASP.NET Core в Azure из образа Docker

Docker Görüntüsünden Azure'da ASP.NET Core Web Uygulaması Nasıl Dağıtılır

Cách triển khai ứng dụng web ASP.NET Core trong Azure từ Docker Image

如何从 Docker 映像在 Azure 中部署 ASP.NET Core Web 应用程序

Crypto trading is a popular and lucrative activity that involves buying and selling different cryptocurrencies on various platforms. Crypto trading apps are applications that allow users to access the crypto market and execute trades from their mobile devices. trading apps can offer various features, such as market analysis, portfolio management, price alerts, news updates, and more. Crypto If you are interested in creating your own crypto trading app, you will need to follow some steps and use some tools to make it happen. In this tutorial, we will guide you through the process of building a basic crypto trading app that can connect to a crypto exchange, display real-time prices, and execute buy and sell orders. Step 1: Setting your cost The cost of developing a crypto trading app depends on various factors, such as the type and complexity of your app, the features and technologies you choose, the size and experience of your development team, the location and rates of your developers, etc. However, as a rough estimate, you can expect to pay between $25,000 and $100,000 for a basic crypto trading app and between $100,000 and $500,000 for a complex . crypto trading app Step 2: Choose a Crypto Exchange API The first step is to choose a crypto exchange API that will provide the data and functionality for your app. A crypto exchange API is a set of endpoints that allow you to interact with a crypto exchange platform programmatically. You can use a crypto exchange API to get market data, such as prices, volumes, order books, and more. You can also use a crypto exchange API to place and cancel orders, check your balance, and manage your account. There are many crypto exchange APIs available, such as [Binance], [Coinbase], [Kraken], and more. Each crypto exchange API has its own documentation, features, limitations, and fees. You will need to choose a crypto exchange API that suits your needs and preferences. For this tutorial, we will use the [Binance API] as an example, but you can use any other crypto exchange API that you like. To use the Binance API, you will need to create an account on [Binance] and generate an API key and a secret key. You will use these keys to authenticate your requests to the Binance API. You can find the instructions on how to create and manage your API keys on the [Binance API documentation]. Step 3: Choose a Programming Language and a Framework The next step is to choose a programming language and a framework that you will use to develop your app. A programming language is a set that you will use to develop your app. A programming language is a set of rules and syntax that allow you to write instructions for a computer to execute. A framework is a collection of libraries and tools that provide common functionality and structure for your app. There are many programming languages and frameworks that you can use to create a crypto trading app, such as [Python], [JavaScript], [Java], [Swift], and more. Each programming language and framework has its own advantages, disadvantages, and learning curve. You will need to choose a programming language and a framework that you are familiar with or willing to learn. For this tutorial, we will use [Python] as the programming language and [Flask] as the framework. Python is a high-level, interpreted, and general-purpose programming language that is easy to read and write. Flask is a lightweight and flexible web framework that allows you to create web applications with minimal code. To use Python and Flask, you will need to install them on your computer. You can find the instructions on how to install Python on the [Python website] and how to install Flask on the [Flask website]. Step 4: Create a Flask App and Connect to the Binance API The third step is to create a Flask app and connect it to the Binance API. A Flask app is a web application that consists of one or more Python files that define the routes, views, and logic of your app. A route is a URL pattern that maps to a view function. A view function is a Python function that handles a request and returns a response. A request is an HTTP message that contains information about the user’s action, such as the URL, the method, the headers, and the data. A response is an HTTP message that contains information about the app’s action, such as the status code, the headers, and the data. To create a Flask app, you will need to create a Python file, such as app.py, and import the Flask module. You will also need to create an instance of the Flask class and assign it to a variable, such as app. You can then use the app variable to define your routes and views. For example, you can create a route for the home page of your app and a view function that returns a simple message: # Import the Flask module
from flask import Flask

# Create an instance of the Flask class
app = Flask(__name__)

# Define a route for the home page
@app.route("/")
# Define a view function for the home page
def home():
    # Return a simple message
    return "Hello, world!" To connect your Flask app to the Binance API, you will need to use a Python library that can handle HTTP requests, such as [Requests]. Requests is a simple and elegant library that allows you to send and receive HTTP requests with Python. You can install Requests on your computer by using the pip command: pip install requests You will also need to import the Requests module in your Python file and use it to make requests to the Binance API. You will need to provide the URL of the Binance API endpoint, the HTTP method, the headers, and the parameters for each request. You will also need to use your API key and secret key to sign your requests. You can find the details on how to use the Binance API on the [Binance API documentation]. For example, you can create a function that gets the current price of a specific cryptocurrency pair, such as BTC/USDT, from the Binance API and returns it as a JSON object: # Import the Requests module
import requests

# Define a function that gets the current price of a cryptocurrency pair
def get_price(pair):
    # Define the URL of the Binance API endpoint
    url = "https://api.binance.com/api/v3/ticker/price"
    # Define the HTTP method
    method = "GET"
    # Define the headers
    headers = {
        # Provide your API key
        "X-MBX-APIKEY": "your_api_key"
    }
    # Define the parameters
    params = {
        # Provide the cryptocurrency pair
        "symbol": pair
    }
    # Make the request to the Binance API
    response = requests.request(method, url, headers=headers, params=params)
    # Return the response as a JSON object
    return response.json() You can then use this function in your view function to display the current price of BTC/USDT on your home page: # Import the Flask module
from flask import Flask

# Create an instance of the Flask class
app = Flask(__name__)

# Define a route for the home page
@app.route("/")
# Define a view function for the home page
def home():
    # Get the current price of BTC/USDT
    price = get_price("BTCUSDT")
    # Return the price as a message
    return f"The current price of BTC/USDT is {price['price']}" Step 5: Create a User Interface and a Database The fifth step is to create a user interface and a database for your app. A user interface is a graphical or textual element that allows the user to interact with your app. A database is a collection of data that is organized and stored in a structured way. To create a user interface for your app, you will need to use HTML, CSS, and JavaScript. For the database, you have many options to choose from; you can use a relational database management system (RDBMS) like SQLite, MySQL, or PostgreSQL. You can use SQLAlchemy, an ORM (object-relational mapping) library for Python, to interact with your database using Python objects and queries. You can use your database to store user information, such as username, password, email, balance, etc., as well as transaction history, such as buy and sell orders, fees, profits, etc. You can use Flask-login, a Flask extension, to manage user sessions and authentication. You can use Flask-WTF, another Flask extension, to create and validate web forms for user input. You can use Flask-Mail, yet another Flask extension, to send email notifications to your users. To use Flask-login, you need to do the following steps: Install Flask-login using pip: pip install flask-login Import the LoginManager class from flask_login and create an instance of it in your app: from flask_login import LoginManager login_manager = LoginManager(app) **Define a User model that inherits from flask_login.UserMixin, which provides default implementations for properties and methods that Flask-login expects from a user object, such as is_authenticated, is_active, get_id, etc. You also need to define a unique identifier for each user, such as an id or a username from flask_login import UserMixin

class User(UserMixin):
    def __init__(self, id, username, password):
        self.id = id
        self.username = username
        self. Password = password Use Flask-SQLAlchemy to create a database and store the User model in it. You can use the db.Model base class to create a table for the User model and use the db.Column class to define the columns for the id, username, and password attributes. Define a user loader function that takes a user identifier as an argument and returns the corresponding user object from the database. You need to decorate this function with the @login_manager.user_loader decorator. Create a sign-up form that allows users to create an account by entering their username and password. You can use the Flask-WTF extension to create a form class that has two fields: username and password. Create a sign-up route that renders the sign-up form template and handles the form submission. You need to check if the username is already taken and if the password is valid before creating a new user and adding it to the database. Create a login form that allows users to log in to their account by entering their username and password. You can also add a remember field which is a boolean value that indicates whether the user wants to be remembered by the browser. Create a login route that renders the login form template and handles the form submission. You need to check if the username and password match the user in the database, and if so, call the login_user function to log in the user. You can also use the remember argument to set the cookie duration for the user. Create a logout route that calls the logout_user function to log out the user and redirect them to the home page. Use the @login_required decorator to protect any routes that require user authentication. This will redirect the user to the login page if they are not logged in. Step 6: Implement Trading Logic and Strategies To implement trading logic and strategies for your app, you can use the Binance API, which you already chose, to access market data and execute orders. You can use requests, a Python library, to make HTTP requests to the Binance API endpoints. You can use pandas, another Python library, to manipulate and analyze market data in tabular format. You can use numpy, yet another Python library, to perform numerical calculations and operations on market data. You can implement different trading strategies for your app, such as market orders, limit orders, stop-loss orders, etc. You can also implement different trading indicators, such as moving averages, Bollinger bands, MACD, RSI, etc., to help you identify trading signals and opportunities. You can use TA-Lib, a technical analysis library for Python, to calculate various trading indicators. You can also use backtesting, a technique to test your trading strategies on historical data, to evaluate their performance and profitability. You can use Back Trader, a Python framework, to perform back-testing on your trading strategies. Step 7: Test and Deploy Your App To test your app, you can use unit test, a Python module, to write and run unit tests for your code. You can use pytest, a , to write and run more advanced tests for your code. You can use coverage, another Python module, to measure the code coverage of your tests. You can also use debugging tools, such as PDB, a Python module, or PyCharm, an IDE (integrated development environment), to find and fix errors and bugs in your code. Python framework To deploy your app, you can use a cloud service provider, such as AWS, Google Cloud, or Heroku, to host your app on a server. You can use Docker, a software platform, to create and run your app in a container, which is an isolated and portable environment. You can use Git, a version control system, to manage your code and track changes. You can use GitHub, a web-based platform, to store and share your code online. You can also use CI/CD (continuous integration and continuous delivery) tools, such as Travis CI, Jenkins, or GitHub Actions, to automate the testing and deployment of your app. I’m going to show you a possible way to deploy your Flask crypto trading app using Docker and GitHub. Step 1: Create a Docker file in the root directory of your Flask app. A Docker file is a text file that contains instructions for building a Docker image. A Docker image is a snapshot of your app and its dependencies that can be run as a container. You can use the following example as a template, but you may need to modify it according to your app’s requirements: # Use an official Python runtime as a base image
FROM python:3.9

# Set the working directory to /app
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# Make port 80 available to the world outside this container
EXPOSE 80

# Define environment variable
ENV NAME World

# Run app.py when the container launches
CMD ["python", "app.py"] Step 7: Push your Flask app code to the GitHub repository. You can use the git add, git commit, and git push commands to do this. You need to provide the URL of your GitHub repository, such as https://github.com/username/flask-app.git. For example: git add .
git commit -m "Initial commit"
git push origin main Step 8: Create a GitHub workflow for deploying your app. A GitHub workflow is a file that defines a set of actions that are triggered by certain events, such as a push or a pull request. You can use the GitHub Actions feature to create and manage your workflows. You need to create a file named .github/workflows/deploy.yml in your repository that contains the following code: # This workflow will deploy your Flask app using Docker and GitHub Actions

name: Deploy

# Controls when the workflow will run
on:
  # Triggers the workflow on push or pull request events but only for the main branch
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This job will deploy your app to a cloud service provider of your choice
  deploy:
    # The type of runner that the job will run on
    runs-on: ubuntu-latest

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v2

      # Sets up Docker
      - name: Set up Docker
        uses: docker/setup-buildx-action@v1

      # Logs in to the Docker registry
      - name: Log in to Docker registry
        uses: docker/login-action@v1
        with:
          # Replace this with the registry name and your username, such as docker.io/username or ghcr.io/username
          registry: docker.io/username
          # Replace this with the name of the secret that contains your registry password, such as DOCKER_PASSWORD or GHCR_TOKEN
          username: ${{ github.actor }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      # Builds and pushes the Docker image
      - name: Build and push Docker image
        uses: docker/build-push-action@v2
        with:
          # Replace this with the name and tag of your image, such as docker.io/username/flask-app:latest or ghcr.io/username/flask-app:latest
          push: true
          tags: docker.io/username/flask-app:latest

      # Deploys the app to the cloud service provider
      - name: Deploy app to cloud service provider
        # Replace this with the action that deploys your app to the cloud service provider of your choice, such as AWS, Google Cloud, or Heroku
        # You may need to provide additional arguments or environment variables for the action, such as the app name, the region, the credentials, etc.
        # You can find more actions in the GitHub Marketplace: https://github.com/marketplace?type=actions
        uses: actions/example-action@v1
        with:
          # Replace this with the arguments for the action
          arg1: value1
          arg2: value2
        env:
          # Replace this with the environment variables for the action
          ENV1: value1
          ENV2: value2 Step 9: Commit and push the workflow file to the GitHub repository. You can use the git add, git commit, and git push commands to do this. For example: git add .github/workflows/deploy.yml
git commit -m "Add deploy workflow"
git push origin main Step 10: Check the status of the workflow. You can use the GitHub web interface to view the progress and logs of your workflow. You can also see the status badge on your README.md file that indicates whether the workflow is successful or not. You can click on the badge to see more details. HOW TO EARN MONEY FROM YOUR CRYPTO TRADING APP The last step of creating a crypto trading app is to monetize your app and generate revenue from it. There are various ways to monetize a crypto trading app, such as: Fees and commissions. You can charge your users fees and commissions for using your platform, such as deposit and withdrawal fees, trading fees, exchange fees, etc. You can also charge your users fees and commissions for using your premium features, such as advanced trading tools, indicators, etc. Ads and sponsorships. You can display ads and sponsorships on your app and earn revenue from the impressions and clicks of your users. You can also partner with other crypto-related businesses and promote their products and services on your app, and earn revenue from the referrals and conversions of your users. Subscriptions and memberships. You can offer your users subscriptions and memberships to access your exclusive content and features, such as premium news and analysis, trading signals, tips, etc. You can also offer your users subscriptions and memberships to join your community and network, such as chat rooms, forums, groups, etc. In Conclusion: creating a crypto-Trading app can be a profiting venture although it can be very complex as you will be considering a lot a business aspect to it.

How to Build Your Own Crypto Trading App: A Step-by-Step Tutorial

How to Automate A Blog Post App Deployment With GitHub Actions, Node.js, CouchDB, and Aptible

কিভাবে GitHub অ্যাকশন, Node.js, CouchDB, এবং Aptible সহ একটি ব্লগ পোস্ট অ্যাপ স্থাপনা স্বয়ংক্রিয়ভাবে করা যায়

So automatisieren Sie die Bereitstellung einer Blog-Post-App mit GitHub Actions, Node.js, CouchDB und Aptible

Cómo automatizar la implementación de una aplicación de publicación de blog con GitHub Actions, Node.js, CouchDB y Aptible

Comment automatiser le déploiement d'une application d'article de blog avec GitHub Actions, Node.js, CouchDB et Aptible

GitHub क्रियाओं, Node.js, CouchDB और Aptible के साथ ब्लॉग पोस्ट ऐप परिनियोजन को स्वचालित कैसे करें

GitHub Actions、Node.js、CouchDB、Aptible を使用してブログ投稿アプリのデプロイメントを自動化する方法

GitHub Actions, Node.js, CouchDB 및 Aptible을 사용하여 블로그 게시물 앱 배포를 자동화하는 방법

Como automatizar a implantação de um aplicativo de postagem de blog com GitHub Actions, Node.js, CouchDB e Aptible

Как автоматизировать развертывание приложения для публикации в блоге с помощью GitHub Actions, Node.js, CouchDB и Aptible

GitHub Eylemleri, Node.js, CouchDB ve Aptible ile Blog Gönderisi Uygulama Dağıtımını Otomatikleştirme

Cách tự động triển khai ứng dụng bài đăng trên blog bằng các hành động GitHub, Node.js, CouchDB và Aptible

如何使用 GitHub Actions、Node.js、CouchDB 和 Aptible 自动部署博客文章应用程序

Docker is a powerful platform that allows you to develop, ship, and run applications inside containers. Installing on Debian is a straightforward process, and in this guide, we’ll walk you through the steps to get Docker Desktop up and running on your Debian-based system. Docker Prerequisites Before we begin, make sure you have the following prerequisites in place: A Debian-based system (such as Debian itself or Ubuntu) Administrative (sudo) privileges Step 1: Adding Docker’s Official GPG Key To ensure the authenticity of Docker packages, we’ll add Docker’s official GPG key to your system. This key is used to verify the integrity of downloaded packages. sudo apt-get update
sudo apt-get install ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg Step 2: Adding the Docker Repository Next, we’ll add Docker’s official repository to your system’s package sources. This repository contains the Docker packages you need. echo "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null Step 3: Updating Package Lists After adding the Docker repository, update the package lists to include the newly added Docker packages. sudo apt-get update Step 4: Installing Docker Now that the package lists are updated, it’s time to install Docker and its components: sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin Step 5: Testing Docker Installation To verify that Docker is installed correctly, run a simple test by executing the following command: sudo docker run hello-world If everything is set up properly, you will see a message indicating that your Docker installation is working correctly. Docker and Docker Compose Version Information $ docker compose version
Docker Compose version v2.17.3

$ docker --version
Docker version 23.0.5, build bc4487a

$ docker version
Client: Docker Engine - Community
 Cloud integration: v1.0.31
 Version:           23.0.5
 API version:       1.42
<...> docker –version: This command displays the version and build number of the Docker Engine. For example, you might get an output like “Docker version 23.0.5, build bc4487a.” This output specifies the installed version of Docker Engine. docker version: It provides more details about Docker Engine, including both client and server versions. It also shows the Docker API version and other details. For instance, you might see “API version: 1.42” in the output. docker-compose version: This command reveals the version of Docker Compose. For example, you might get an output like “Docker Compose version v2.17.3.” This version specifies the installed version of Docker Compose. These commands are used to determine which versions of are installed and to display information about their capabilities. Docker Compose is a tool used for defining and running multi-container applications, while Docker is a containerization platform used for creating and running containers. Using these commands, you can check the versions of Docker and Docker Compose installed on your system without any issues. Docker and Docker Compose Enabling Docker to Start at Boot sudo systemctl enable --now docker The command sudo systemctl enable –now docker is used to enable the Docker service to start automatically at boot time on a Linux system using systemd, the init system commonly used on modern Linux distributions. Here’s what each part of the command does: sudo: It is used to run the following command with superuser privileges, which are typically required for system-level configurations. systemctl: This is a command used to manage systemd, which is the init system responsible for managing services and processes on a Linux system. enable: This option tells systemctl to enable the specified service. Enabling a service means that it will start automatically at system boot time. –now: This option is used in conjunction with enable to not only enable the service but also start it immediately. It ensures that the service is active right away. docker: This is the name of the service we want to enable and start, in this case, the Docker service. When you run this command, it ensures that the Docker service will be started automatically every time the system boots up. Enabling Docker to start at boot is important because it allows Docker containers to be managed and run as soon as the system starts, ensuring that your containerized applications are available without manual intervention. Docker Commands Docker is an essential tool for container-based application development and deployment. In this article, we’ll explore two crucial Docker commands: docker ps -a and docker run -it debian bash. Both commands help us utilize Docker’s fundamental capabilities and are valuable when working with containers. docker ps -a This command lists all Docker containers and their historical states. Here’s a detailed explanation: docker ps: This command lists only the running Docker containers, providing an overview of the containers currently active. docker ps -a: The -a or –all flag is used to list all Docker containers, including both running and exited ones. This is crucial for examining the historical states of containers and potentially restarting them when needed. sudo docker run -it debian bash This command allows you to start a new Docker container and interactively access its shell. Here’s a breakdown of this command: docker run: This command is used to initiate a new Docker container. -it: These flags enable an interactive terminal session within the container. -i enables interactive mode, while -t allocates a terminal. debian: This specifies the name of the Docker image to be launched. In this example, we are using a Debian Linux-based container. bash: This specifies the command to run within the launched container. In this case, we are starting a bash shell, allowing us to interact with the container’s environment and execute commands. By using this command, you can launch a new Debian Linux container and access an interactive shell inside it. This enables you to work within the container, facilitating various development and debugging tasks. These two Docker commands are frequently used for basic container operations, making them valuable tools when working with Docker. Conclusion Congratulations! You have successfully installed on your Debian-based system. Docker is now ready to help you manage containers and streamline your development process. Start exploring the world of containerization and take full advantage of Docker’s capabilities. Docker Desktop Happy containerizing! Also published . here

Installing Docker Desktop on Debian and Maximizing Container Management

In contemporary software engineering practices, the paramount significance lies in Continuous Integration (CI) and Continuous Delivery/Deployment (CD). CI/CD pipelines are engineered with the primary goal of enabling developers to integrate recent software modifications into a production environment both expediently and securely. This, in turn, fosters business value. It is pivotal not only for engineers but also for business strategists to discern the nuances between continuous integration, delivery, and deployment. Often, it is observed that teams efficiently navigate continuous integration but inadvertently overlook the facets of delivery or deployment, potentially hindering the full realization of CI/CD benefits. The prominence of CI/CD received a significant boost in 2021 with the emergence of novel paradigms like GitOps and MLOps. These advancements elevated CI/CD to a preeminent position, championing interdisciplinary alignment and innovative operational methodologies. Such progressions underscore the imperative nature of a holistic comprehension of CI/CD. With the increasing adoption of Agile methodologies in the realm of software development, CI/CD has become indispensable. Agile tenets advocate for automated testing as a conduit for rapid software iteration. This enables stakeholders to readily access novel functionalities and ensures swift feedback loops. Automated testing not only upholds software quality but also provides immediate insights into potential inefficiencies or issues, facilitating prompt rectifications. In this evolving landscape, it becomes imperative to foster a comprehensive understanding of the entire spectrum of CI/CD, while concurrently assimilating the emerging methodologies, in order to maintain competitiveness and drive innovation. Within the current software development milieu, the efficacy of a CI/CD pipeline transcends the conventional boundaries of continuous integration and delivery; it embodies the essence of agility. The establishment of a CI/CD workflow designed to facilitate swift provisioning of environments, showcase Minimum Viable Product (MVP) demonstrations, or cater to staging environments assumes paramount significance. In this context, we shall embark on a comprehensive exploration of the intricate process involved in establishing a robust CI/CD workflow leveraging the capabilities of GitHub Actions. This pipeline seamlessly executes the transformation of a Python application into a Docker container, followed by its deployment onto a development server via Docker Compose. This orchestration encompasses all essential components, including databases and message queues, as well as other indispensable infrastructure elements. Overview of CI/CD tools, in particular GitHub Actions The domain of Continuous Integration and Continuous Delivery/Deployment (CI/CD) boasts a variety of tools, each crafted to simplify and streamline the software development lifecycle. These tools cater to different stages and aspects, from code integration to automated testing, and from release management to deployment (table 1). Among these myriad tools, GitHub Actions emerges as a particularly notable solution. Table 1. CI/CD Tool CI/CD Tool Primary Purpose Jenkins An open-source automation tool for continuous integration and delivery with a wide range of plugins and integrations. Travis CI A cloud-based continuous integration service tightly integrated with GitHub repositories. CircleCI Offers cloud-based CI/CD pipelines with Docker support and efficient caching strategies. GitLab CI/CD Provides an integrated CI/CD solution within the GitLab platform, covering the entire software development lifecycle. Bamboo Atlassian's CI/CD server solution, integrating closely with tools like Jira and Bitbucket. TeamCity A server-based CI/CD tool offering extensive build and deployment configurations. GitHub Actions Integrated within GitHub, it automates software workflows in the repository environment. Supports triggers like pull requests, code merges, and offers actions in modular blocks. Azure Pipelines Microsoft Azure's CI/CD solution that supports any platform and cloud, integrating seamlessly with GitHub. AWS CodePipeline Amazon Web Services' continuous integration and continuous deployment service. Spinnaker An open-source, multi-cloud continuous delivery platform that integrates with CI tools and supports complex deployment strategies. GitHub Actions is a CI/CD tool seamlessly integrated into the GitHub platform. Its design aims to automate software workflows directly within the repository environment. Unlike some other CI/CD solutions that necessitate external integrations or complex configurations, GitHub Actions offers a more intuitive and repository-centric approach. It facilitates automatic execution of software pipelines upon a multitude of triggers, ranging from pull requests to issue creations and code merges. Underpinning GitHub Actions is a series of predefined 'actions'—modular and reusable blocks of code. These actions can be orchestrated in workflows to define an end-to-end automation process. The system's architecture is built on flexibility: developers can utilize predefined actions from the GitHub marketplace or create bespoke ones tailored to specific project needs. This granular control, combined with GitHub's native environment, makes GitHub Actions a favored choice for many software engineers, both novices and veterans. Furthermore, with the evolving landscape of software development that now includes Docker containerization and deployment orchestration, GitHub Actions has kept pace. It supports building, testing, and deploying Docker containers, enabling modern microservice-based applications to be efficiently developed, tested, and deployed. In summary, while the CI/CD ecosystem is expansive and multifaceted, GitHub Actions stands out for its adaptability, integration within a popular version control platform, and comprehensive approach to modern software delivery challenges. Purpose and objectives of the work The overarching objective of this research paper is to elucidate the process of implementing a CI/CD pipeline using GitHub Actions, with a specific focus on building and deploying Docker images from a Python-based project. This study aims to demonstrate how contemporary CI/CD practices, when married with powerful tools like GitHub Actions, can significantly enhance the software development and deployment lifecycle, especially in the context of Python applications containerized via Docker. The tasks integral to achieving this objective are manifold: To provide a comprehensive understanding of the prerequisites necessary for the CI/CD implementation, including the acquisition of a GitHub repository, ensuring SSH server access, and establishing an account on Docker Hub or an alternative container registry. To meticulously detail the process of setting up GitHub Secrets— a foundational step ensuring the secure storage and utilization of sensitive data such as SSH keys and authentication tokens. To describe the formulation and implementation of a GitHub Actions workflow that spans from code checkout to deployment on a development server. To provide insights into the intricacies of each workflow step, highlighting their significance and offering guidance on their optimal configuration and execution. Through the fulfillment of these tasks, this study endeavors to present readers with a cohesive, actionable blueprint for leveraging GitHub Actions in the realm of Python software development and Docker container deployment. Prerequisites and requirements To effectively implement the described CI/CD pipeline using GitHub Actions, several prerequisites and requirements must be met (Fig. 1). These are instrumental in ensuring seamless integration, containerization, and deployment processes. GitHub Repository: At the core of the process lies the need for a GitHub repository. This repository will house the Python application codebase and facilitate the integration with GitHub Actions. Additionally, it serves as the central hub for version control, ensuring traceability and collaboration. SSH Server Access: To facilitate the deployment phase, one must possess SSH access to the target server. This secure protocol ensures that the process of code transfer and execution on the server remains both reliable and safeguarded against potential security vulnerabilities. Container Registry Account: Given the emphasis on Docker for containerization, an account on Docker Hub or a comparable container registry becomes imperative. This registry will store the Docker images built during the CI process, making them available for subsequent deployment. Furthermore, it acts as a centralized repository, ensuring versioning, and easy rollback of containerized applications. Understanding and fulfilling these prerequisites is pivotal to guarantee a successful and efficient CI/CD implementation. By ensuring these foundational elements are in place, one sets the stage for a streamlined and effective integration and deployment process facilitated by GitHub Actions. CI/CD Pipeline implementation Step 1: Setting up the GitHub Secrets In the preliminary phase of establishing an efficient CI/CD pipeline using GitHub Actions, the paramount step pertains to the configuration of GitHub Secrets. These secrets function as encrypted environmental variables, shielding sensitive data from unintended exposure while still making it accessible for the required automation tasks. To set up these pivotal secrets, one should first access their respective GitHub repository. Within the repository's interface, navigating to the "Settings" tab reveals the "Secrets" option. Utilizing this facility allows the user to input specific key-value pairs that the GitHub Actions workflow will later rely upon. Key secrets to be configured include: DOCKERHUB_USERNAME: Docker Hub username. DOCKERHUB_TOKEN: Docker Hub token. SSH_PRIVATE_KEY: Server's private SSH key. HOST: Server IP or domain name. SSH_USERNAME: SSH username for the server. Upon the successful configuration of these secrets, the foundation is laid for the forthcoming GitHub Actions workflow. This workflow, defined within the .github/workflows/deployment.yml file, will leverage these secrets to ensure seamless and secure execution of the CI/CD tasks. Following the initial configuration of GitHub Secrets, a deeper examination of each successive stage in the CI/CD pipeline using GitHub Actions is imperative to ensure an effective, secure, and efficient software delivery process. Step 2: Repository Checkout This stage is characterized by retrieving the GitHub repository's content. By doing so, the necessary codebase becomes accessible to the GitHub Actions runner for all subsequent stages. This retrieval operation is facilitated through the actions/checkout@v2 action. Step 3: QEMU Configuration This phase focuses on empowering the pipeline with the capability of creating multi-architecture Docker images. By leveraging QEMU, it allows Docker images to be compatible across diverse hardware architectures, enhancing the universality of deployments. The utilized action for this is docker/setup-qemu-action@v2. Step 4: Docker Buildx Initialization The objective here is to harness Buildx, a CLI plugin for Docker, ensuring that multi-architecture Docker images can be crafted with ease. This is realized using the docker/setup-buildx-action@v2 action. Step 5: Docker Hub Authentication A crucial step that authenticates the GitHub Actions runner with Docker Hub. This connection, established through docker/login-action@v2, paves the way for Docker image pushes, with authentication credentials specified via the inputs: the Docker Hub username and the corresponding token. Step 6: Docker Image Construction & Deployment This phase pivots around the creation of a Docker image from the repository's Dockerfile. Once crafted, this image is then dispatched to Docker Hub. Achieved using docker/build-push-action@v2, it specifies the image's context, ensures it's pushed to Docker Hub, and provides it with a definitive tag. Step 7: SSH Key Configuration By leveraging shimataro/ssh-key-action@v2, this step outfits the runner with the means to securely establish SSH communications with the development server. It uses the server's private SSH key and disregards host verification for simplicity in this configuration. Step 8: Known Hosts Addition This is a supplementary security step ensuring that SSH connections are perceived as legitimate. By running the ssh-keyscan command, it acquires and appends the server's public SSH key to the known hosts file, strengthening the security posture. Step 9: Deployment on Development Server Concluding the pipeline, the docker-compose.yml file is securely transported to the development server using the rsync utility. Once transferred, an SSH session is established, directing the server to initiate the services detailed in the docker-compose.yml through the Docker Compose command. Services are initiated in a detached mode, ensuring their persistence post-execution. Step 10: Directory Navigation and Deployment Upon successfully transferring the necessary files to the development server, the next logical phase is to initiate the Dockerized services. This step involves an SSH session into the development server. Once accessed, the system navigates to the specified project directory. Within this directory, the Docker Compose command is executed, orchestrating the launch of the defined services in the docker-compose.yml file. The use of the -d flag in the docker-compose up command ensures that the services are run in a detached mode. Consequently, they continue their operation independently of the session, ensuring persistent and uninterrupted service even post command completion. This maneuver, streamlined through the combination of ssh, cd, and docker-compose up -d, culminates the CI/CD pipeline by effectively transitioning from code changes to an active, deployed service. In essence, these stages, when executed cohesively, ensure a fluid and secure transition from code modification to deployment, emphasizing the transformative potential of GitHub Actions in the CI/CD framework. Tips and tricks While the adoption and implementation of a CI/CD pipeline, especially one anchored on GitHub Actions, offer numerous advantages, it's essential to remain apprised of certain best practices to extract maximum efficiency and security. Multi-Architecture Awareness: While QEMU and Buildx are integrated into the presented workflow to ensure multi-architecture compatibility for Docker builds, their utilization may not be universally pertinent. Teams not seeking to deploy across varied hardware architectures might find it advantageous to omit these steps, leading to a more concise pipeline. SSH Key Management: The safety and security of SSH keys are paramount. Directly embedding or inadvertently logging these keys can lead to security breaches. The presented approach uses GitHub Secrets, which encrypts these sensitive credentials, ensuring they remain concealed. Adhering strictly to such practices mitigates risks associated with unauthorized access. Optimizing Build Times: The efficiency of the CI/CD process is often tethered to the speed of its builds. Given the potential size and complexity of applications, leveraging caching mechanisms, especially during Docker builds, can significantly expedite the process. By caching unchanged layers, rebuild times can be reduced, leading to faster feedback and deployment cycles. Testing in Production Environments: As the workflow delineated focuses on deployment to a development server, it's worth noting that additional considerations are required for production settings. Employing more advanced orchestration tools, such as Kubernetes, can ensure that applications scale and perform optimally when subjected to real-world traffic and demands. Continuous Feedback Loop: Integral to the spirit of CI/CD is the cultivation of a continuous feedback loop. This ensures not only that software functions as intended but also fosters an environment of constant iteration and improvement. Automated testing provides immediate feedback to developers, but it's equally pivotal to have mechanisms that capture and relay user feedback post-deployment. In essence, while the tools and methodologies provided create a robust CI/CD foundation, it's the judicious adherence to best practices and a commitment to continuous improvement that ensures enduring success in software delivery endeavors. Conclusion In the ever-evolving landscape of software development, the integration of CI/CD pipelines stands as a testament to the industry's dedication to efficiency, consistency, and quality. This research has endeavored to illuminate the intricacies of harnessing GitHub Actions to facilitate a seamless transition from codebase modifications to Docker container deployments, specifically for Python applications. The significance of a well-structured CI/CD pipeline is evident. It not only streamlines the software delivery process but also ensures that applications remain robust, scalable, and aligned with stakeholder expectations. The meticulous delineation of the process, from setting pre-requisites to understanding each nuance of the pipeline stages, underscores the multifaceted nature of modern software deployment. GitHub Actions, with its intrinsic integration capabilities and flexibility, emerges as a pivotal tool in this realm. While the technical steps and mechanisms have been elucidated, it is imperative to note that the true strength of any CI/CD pipeline lies in its adaptability. The software industry is characterized by its rapid advancements, and a rigid pipeline will soon find itself obsolete. Therefore, continuous evaluation, iteration, and incorporation of best practices are non-negotiable for teams aspiring for excellence. In summation, the journey from code to deployment, when navigated with precision, foresight, and an understanding of tools like GitHub Actions, can transform software delivery from a cumbersome task into a streamlined, efficient, and rewarding process. As the industry continues to advance, such methodologies will undoubtedly play a central role, guiding teams to deliver software that resonates with quality and innovation.

Implementing CI/CD with GitHub Actions: Building and Deploying Docker Images from a Python Project

There is no doubt that the cloud has changed the way we run our software. Startups, for instance, can get started without buying expensive hardware and scale flexibly. Also, the cloud has enabled novel solutions such as serverless, managed Kubernetes and Docker, or edge functions. For a time, cloud-native applications seemed to be the way forward for most teams, big or small. But in exchange for all this power, we pay a cost. And it can be a steep one. — the company behind and — has calculated that by buying a few servers and moving from the cloud to on-premise, they can save . 37signals HEY.com Basecamp.com 7 million dollars over 5 years And it is not an isolated case. Recently, Amazon Prime — the poster child of serverless architectures — moved part of its infrastructure from and cut costs by 90%. serverless into a monolith Does this mean that we should go back to bare metal servers like in the old days? Not quite. We can still enjoy many of the benefits of the cloud, like horizontal scalability and no-outage upgrades using containers in combination with an orchestration platform. On that note, 37signals recently released , a tool that allowed them to , saving them money and improving performance for their users. MRSK completely leave the cloud What is MRSK? MRSK is a deployment tool for containerized applications. It uses Docker containers to run the software and Traefik, a reverse proxy and load manager, to perform rolling updates. The application container runs behind an instance of Traefik running as a reverse proxy. User requests are routed to the active application container. MRSK keeps things simple by: Using standard Docker images. Connecting to the servers via SSH. Giving each server a single role. The last point gives us the first clue about how MRSK works. It assumes a multi-server setup, where every machine fulfills only one role. In other words, if your application requires a database, MRSK expects to have at least two servers: one for the application and one for the database. Deploying the application and database with a single MRSK command. MRSK cares about your servers and little else. Load balancing is limited to the server level. MRSK uses Traefik to forward HTTP traffic to every container running on a machine. If you want to do horizontal scaling, you'll need to put a separate load balancer in front of everything. MRSK does not manage multi-server load balancing. You need to add your own. Because MRSK doesn't care where the application runs, you can use a cloud server, on-premise machines, or even run VMs on your laptop to test drive the tool. Getting started with MRSK You'll need the following to build and deploy an application with MRSK: Docker. A Docker Hub account or similar. A software project with its Dockerfile. Two servers with SSH access. : we will need at least one server for each role. A deployment will typically need at least two machines: one for the application and one for the database. Note You cannot host the database on the same machine as the application. Ensure you have SSH access. Before starting, ensure that you have SSH access to the deployment server. It can be any cloud, bare metal server, or even a VM on your laptop. What matters is that it already has your SSH key authorized for root access. $ ssh root@SERVER_IP_ADDRESS If that doesn't work, but you know the root's password, you can add your key with the following command: $ ssh-copy-id root@SERVER_IP_ADDRESS Installing MRSK So, now that we have our server, we can install MRSK on your local machine. Either as a Ruby Gem: $ gem install mrsk -v 0.13.2 Or, you can try the ready-made official Docker image by aliasing the command in your shell like this: $ alias mrsk='docker run --rm -it -v $HOME/.ssh:/root/.ssh -v /var/run/docker.sock:/var/run/docker.sock -v ${PWD}/:/workdir ghcr.io/mrsked/mrsk:v0.13.2' Since MRSK is in active development and quite new, I suggest picking a version and sticking with it to prevent updates from breaking your deployments. Configuring MRSK For this next step, we will need a project to deploy. MRSK works with any codebase as long as it includes a Dockerfile. For this tutorial, I will be using the following demo project, which exposes an API-based address book with PostgreSQL for persistence: TomFern/dockerizing-nodejs In the project's root folder, run: $ mrsk init This will create three files: : the main configuration file. It declares how to deploy the application to all your servers. config/deploy.yml : for sensitive environment variables, including passwords and tokens. It should be added to so it's never checked in the repository. .env .gitignore : contains Git-like hooks. We won't be using any of these features in this tutorial. .mrsk/hooks The building block of MRSK deployments is called , which are containers running in one or more servers. They are connected to the Internet via , a reverse proxy. applications Traefik Let's configure our deployment. To do that, open deploy.yml and edit the following values near the top of the file. Uncomment the lines as needed. You will, at the very least, need to define the following: A name for the application. The server IP address. This will be your application server. The Docker image name without the tag. Your Docker Hub username (you can also use a different registry). In the registry.password add "DOCKER_PASSWORD". This is a reference to a variable defined in .env. Environment variables for the application. The values under clear are stored in plaintext. Passwords should be stored in .env, and their variable name should be listed under secret in the config file. I'm configuring an "addressbook" application in the example below. Its image name is TomFern/addressbook (notice the lack of tags, which are handled by MRSK). My application uses a PostgreSQL database, for which I set to the IP address of the db and reference the variable containing the password in . DB_HOST .env service: addressbook
image: tomfern/addressbook

# Deploy to these servers.
servers:
 - 216.238.101.228

# Credentials for your image host.
registry:
 username: tomfern
 password:
 - DOCKER_PASSWORD

# Environment variables
env:
 clear:
 DB_HOST: 216.238.113.141
 secret:
 - DB_PASSWORD MRSK can handle containerized dependencies like databases, caches, or search services. MRSK calls them . If you need to define an accessory, scroll down the config file until you find the section. Then, set the following values: accessories accessories The db engine image name with its tag, e.g. . postgres:14 The db server IP address and the database port. Any secrets or environment variables needed for database initialization. One or more volume mappings for data persistence — so data is not wiped out when the container stops. You can also define startup scripts to run during database initialization. The following snippet shows how to configure a PostgreSQL database accessory for our demo app: accessories:
 db:
 image: postgres:14
 host: 216.238.113.141
 port: 5432
 env:
 secret:
 - POSTGRES_PASSWORD
 volumes:
 - /var/lib/postgresql/data:/var/lib/postgresql/data Now, open the file. Fill in the password of your Docker Hub account and for the "Postgres" user in your PostgreSQL server. The value of every secret environment variable defined in must be set here. .env deploy.yml DOCKER_PASSWORD=YOUR_DOCKER_HUB_PASSWORD
POSTGRES_PASSWORD=THE_POSTGRES_ADMIN_PASSWORD
DB_PASSWORD=THE_ADDRESSBOOK_APP_PASSWORD You may use the same password for and or create a dedicated user for the app in the database. If you do so, you'll also need to define in the config file like this: POSTGRES_PASSWORD DB_PASSWORD DB_USER service: addressbook
image: tomfern/addressbook

# ...

env:
 clear:
 DB_HOST: 216.238.113.141
 DB_USER: my_app_username
 secret:
 - DB_PASSWORD Add a healthcheck route By default, MRSK checks that the application container is up by running curl on the route. You can change the healthcheck endpoint in the config file. /up Since the demo does not have a healthcheck route, let's add one. In , add the following lines: app.js // app.js

// ....

const healthRouter = require('./routes/health');
app.use('/up', healthRouter);

// ... And create a new file called with the following content, which checks if the app can connect with the database: routes/health.js // routes/health.js


const express = require('express');
const router = express.Router();
const db = require('../database');

router.get("/", function(req, res) {
 db.sequelize.authenticate()
 .then(() => res.status(200).send(JSON.stringify({ ok: true })))
 .catch( err => res.status(500).send(JSON.stringify(err)));
});

module.exports = router; MRSK uses curl inside the container to perform the healthcheck, so ensure that your Dockerfile installs the tool. For example: FROM node:18.16.0-alpine3.17
RUN apk update && apk add curl

... Prepare servers and deploy We're set to begin with the deployment. MRSK can do everything with a single command: $ mrsk setup

Acquiring the deploy lock
Ensure curl and Docker are installed...
Log into image registry...
Build and push app image...
Ensure Traefik is running...
Start container with version c439617 using a 7s readiness delay (or reboot if already running)...
Releasing the deploy lock This command does the following: Installs Docker on all machines. Starts Traefik in the app server. Starts the PostgreSQL container in the database server. Builds the Docker image for your application on your laptop and uploads it to Docker Hub. Pulls the image and starts the application on the server. Routes inbound traffic into the application container. MRSK runs a health check to verify that the application is ready to work before being exposed to the Internet. Once the check passes, Traefik routes traffic into the app's container. By default, the health check is a GET request to the route (expecting status code 200), but you can change that in . /up deploy.yml MRSK deployment mechanism. The image is built into the developer's machine, uploaded to Docker Hub, and pulled into the server. Then, a health check ensures it starts correctly. Once verified, Traefik routes traffic into the application container. We can check what containers are running with the following: $ mrsk details

Traefik Host: 216.238.101.228
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5d08d56b760b traefik:v2.9 "/entrypoint.sh --pr…" 2 minutes ago Up 2 minutes 0.0.0.0:80->80/tcp, :::80->80/tcp traefik

App Host: 216.238.101.228
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
28acfd2cda02 tomfern/addressbook:3ecd87430ab7ab6cc30a1542784ddb75fbfd8e74 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 3000/tcp addressbook-web-3ecd87430ab7ab6cc30a1542784ddb75fbfd8e74


CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a843852686b6 postgres:14 "docker-entrypoint.s…" 2 minutes ago Up 2 minutes 0.0.0.0:5432->5432/tcp, :::5432->5432/tcp addressbook-db As you can see, MRSK tags every built image with a unique identifier, allowing us to track changes, rolling back and forwards as needed. Before testing the application, we should run any database migration/setup scripts to initialize its contents. MRSK allows us to run commands in running containers with the following: $ mrsk app exec "npm run migrate" Finally, we can test the application, which should be ready to receive user requests. $ curl -X PUT http://216.238.101.228/persons -H 'Content-Type: application/json' -d '{
"id": 1,
"firstName": "David",
"lastName": "Bowie"
}'

$ curl 216.238.101.228/persons/all
{
 "firstName": "David",
 "lastName": "Bowie",
 "id": 1,
 "updatedAt": "2023-04-30T22:44:29.115Z",
 "createdAt": "2023-04-30T22:44:29.115Z"
} Deploying updates with MRSK Let's make a change to the application so we can see how MRSK handles updates. In the demo code, we have a API endpoint; it would be a good idea to version it. So let's change this line in : /persons app.js app.use('/persons', personsRouter); Change the line so the base endpoint route is . /persons/v1/ app.use('/persons/v1', personsRouter); The fastest way to update the container is with , which does away with a few tasks like checking whether Docker is installed in all servers. mrsk redeploy $ mrsk redeploy

Acquiring the deploy lock
Running docker buildx build
Running docker image rm --force tomfern/addressbook:7db892 on 216.238.101.228
Running docker pull tomfern/addressbook:latest on 216.238.101.228
Health check against /up succeeded with 200 OK!
Finished all in 35.8 seconds
Releasing the deploy lock The redeploy command will rebuild the image, upload it to Docker Hub and start it on the application server. As soon as the health check passes, the traffic is routed to the new version, and the old container shuts down. MRSK redeploy mechanism. A new instance of the application is built and deployed. Once its health check passes, traffic is routed to the new instance, and the old one is shut down. After deployment, we can check that the new route is working: $ curl 216.238.101.228/persons/v1/all

[
 {
 "id": 1,
 "firstName": "David",
 "lastName": "Bowie",
 "createdAt": "2023-05-07T17:41:45.580Z",
 "updatedAt": "2023-05-07T17:41:45.580Z"
 }
] Rolling back updates with MRSK MRSK gives us a safe path for rolling back updates. If the new version is causing trouble, we can return to the last working version with a single command. To rollback, first, we need to find which images are available on the server with the following: $ mrsk app containers

App Host: 216.238.101.228

CONTAINER ID   IMAGE                                                          COMMAND                  CREATED         STATUS                     PORTS      NAMES

f648fec5f604   tomfern/addressbook:66347a86f8a123e35492dd43463540c23f7db892   "docker-entrypoint.s…"   4 minutes ago   Up 4 minutes               3000/tcp   addressbook-web-66347a86f8a123e35492dd43463540c23f7db892

b3b1d13b8a1c   9500e07b6387                                                   "docker-entrypoint.s…"   9 minutes ago   Exited (1) 4 minutes ago              addressbook-web-66347a86f8a123e35492dd43463540c23f7db892_05d41f3ba39d2b1b

ce4a5c31e6fc   tomfern/addressbook:f043325e3984ec245a94b21bd236afcc537a9739   "docker-entrypoint.s…"   3 hours ago     Exited (1) 9 minutes ago              addressbook-web-f043325e3984ec245a94b21bd236afcc537a9739 We can see that the previous version was tagged as "f043325e3984ec245a94b21bd236afcc537a9739". We can run to go back to it. For example: mrsk rollback $ mrsk rollback f043325e3984ec245a94b21bd236afcc537a9739 If the container does not exist on the server — MRSK routinely prunes older images — you can always look up the last good version in Docker Hub or by checking the logs in your CI/CD platform. MRSK rollback mechanism. The old version is restarted and health-checked. Once working, traffic is switched over to the old version, and the new container stops. Once you're done with your application, you can remove everything, including the database, with mrsk remove. This will destroy the database, remove Docker and stop all applications. MRSK’s limitations MRSK development is ongoing, so we may expect behavior changes and new breaking features in the future. But do not mistake its newness for immaturity; 37signals has reportedly begun using it to move away from the cloud with great success already. That being said, there are a few things MRSK cannot do, and that makes it a bad fit for some use cases: The default behavior is to expose the application's HTTP port without SSL. You are supposed to set up an SSL terminator, a load balancer, or a CDN in front of the whole deployment. Containers cannot communicate between themselves within the same server. This is . You can always configure Docker networks server-side manually. But it's better to stick to one server per role, so putting the application and the database on the same machine is a bad idea. by design You will need to configure a firewall in front of your whole setup to ensure users can only access the web application. If you want to distribute the load among many servers, you should set up a load balancer in front of your servers. MRSK does not provide this feature. MRSK is designed for each server to have one role and does not provide load balancing or SSL termination. You need to handle it by yourself. At the end of the day, MRSK offers a simplified workflow — especially when compared with beasts like Kubernetes — by not trying to handle every aspect of the system. Troubleshooting If you experience issues with deployment, try the following: If the healthcheck fails, ensure that curl is installed in the application container image. If it still fails after ensuring curl is installed, check that connectivity works between the application and the database. You may need to configure a VPS or set firewall rules. You can try starting the images manually by running the docker exec commands in the machines to see the output of the logs. These will help you find the root cause of the problem. If you get an error message stating that there is a lock, run mrsk lock release. This can happen when MRSK fails during deployment, and the admin lock is not released. Conclusion MRSK is minimalistic to the point of elegance. By combining traditional servers with the flexibility of containers, it allows us to run our containerized services with ease on any server. MRSK presents a compelling solution if you're seeking to optimize your software deployments, reduce vendor lock-in, and maintain flexibility in choosing deployment environments while enjoying the benefits of cloud-native architectures. Also published . here

Unlocking Freedom from the Cloud: Empower Your Apps with MRSK's Optimal Orchestration

Unlock the power of Kali Linux on Docker networks by adding a GUI back to the container and level up information gathering with anonymized web scraping powered by Python, Selenium, and Tor Browser. As a DevOps Engineer, I have both shipped, and enabled other Engineers to ship, many hundreds of thousands of containers. I use Continuous Delivery and a variety of orchestration methods:  Kubernetes, Lambda Containers on AWS, Elastic Container Service (ECS) backed by both Elastic Compute Cloud(EC2) and Fargate. Containers are useful for custom build systems, automated deployments, vulnerability scanning, research purposes, data analytics, machine learning, legacy software archival, local development, and web scraping. In this guide I will go over the steps I went through to add a GUI to the official using Xvfb and a VNC server. The code I discuss here is published in the open source repository, and is continuously delivered to for general use. Finally, in Part 2 of this series, everything in the containers will be put to the test. I will use a custom Python script, Pytest, and Selenium to automate the Tor Browser instance and gather data from the web. Kali Linux container from DockerHub kalilinux-xvfb Docker Hub Container Networks Part of the motivation behind having Kali Linux in a container is to gain visibility into the private network space created by the host machine for containers. The default setup from Docker Desktop is to use a NAT network. Unless the port(s) are bound to the host machine, with , that service will not be accessible from the host. docker run -p The Software Here are added summary sections with links for each of the following software packages: Kali Linux Docker Desktop Tor Browser Tor Browser Launcher Xvfb Selenium Additional links for software I used: Xfce 4 Tight VNC Server OpenSSH Server and Python3 Pip3 Geckodriver Kali Linux Kali Linux is a Debian-based Linux distribution aimed at advanced Penetration Testing and Security Auditing. 1 I chose Kali Linux for the sheer amount of security focused tools that are available. The Kali Linux team provides a Docker image that is updated regularly. Much of the required software is available to the Kali Linux Docker image and I will be using the package manager to install them. Docker Desktop is a framework for running containers locally. Containers are a way of packaging operating system and application state in a reusable operating system image. Additional resources are available on the . Docker Desktop Docker website Containers and virtual machines have similar resource isolation and allocation benefits, but function differently because containers virtualize the operating system instead of hardware. 2 Since Docker containers are more lightweight than virtual machines, I favor them heavily in my development efforts. Long term, this state can be stored as a small text file and is a lot easier to track changes over time with git and similar tools. The ability to derive an image again from a text file is powerful. However, it is entirely possible for a Dockerfile to fall into disrepair over time and could fail to build at a later date. Much like any other Operating System, and Infrastructure as Code, it is important to keep everything up to date. An alternative to Docker would be to use a Virtual Machine, or a bare metal installation. However, I believe containers are the perfect testbed for running ephemeral web crawlers because they are easy to provision and cleanup. I can run many containers on a single machine,  in parallel, that can be started and stopped almost instantly. Then whenever I require additional isolation this whole setup can be run from inside a virtual machine as well. Tor Browser The Onion Router (Tor) is a global network of computers that route traffic through a series of encrypted hops. This allows for a user to browse the internet somewhat anonymously, and also allows for a user to access websites that are only available on the Tor Network. is a heavily configured version of Firefox with a focus on privacy and security. It can use the Tor Network out of the box. Tor Browser is included in many Linux operating systems and makes starting a web browser on the Tor Network extremely easily. torbrowser-launcher Selenium is a tool for automating web browsers. I went with Python in this example, but there are many languages and tools available. Selenium I will be using Selenium to automate this Tor Browser on the Tor Network. I am  attempting to take advantage of the security conscious browser's existing config to limit sharing of information to targets. I will be able to clean up the containers runtime states by stopping them. The resulting WebDriver session will have a random IP address vended through Tor, making it a very powerful tool for web scraping. Xvfb The XOrg component can be used to simulate a screen to the X window system. I will then use this screen to start an X server in the container. This emulation technique is not particularly fast, and graphics heavy applications will benefit from a GPU. Xvfb Overview of the Files The Dockerfiles should build on any Linux, macOS, or Windows distribution that can run Docker. I have tested this on Docker Desktop using an Intel processor. There is an ARM variant for the official Kalilinux base container. I would appreciate feedback from anyone that tries running this on ARM. Dockerfile TorBrowser.Dockerfile TorBrowser-root.Dockerfile startx-once.sh start-vnc-server-once.sh ssh-keys.sh torrc .github/workflows/main.yml Dockerfile This is the Dockerfile that I used to build the base image. I have added a few comments to explain what each line does. # From the official Kali Linux Docker image rolling release
FROM kalilinux/kali-rolling

# Leaving this here for now, but it's not needed
ARG DISPLAY_NUMBER=1
ENV DISPLAY=:$DISPLAY_NUMBER

# Install the packages we need
# Got lucky with this one, there was a ticket about this:
# https://github.com/dnschneid/crouton/issues/4461 `xfce4 dbus-launch not found` in this version of the image so installing dbus-x11
RUN apt-get update -y -q \
  && apt-get install -y -q xvfb xfce4 xfce4-goodies tightvncserver net-tools curl openssh-server dbus-x11

# This line copies the shell scripts from the local directory to the container, and makes them executable.
COPY *.sh /opt/
RUN chmod 755 /opt/*.sh

# This line runs the shell scripts that start the X server, and generate the SSH keys.
RUN /opt/startx-once.sh
RUN /opt/ssh-keys.sh

# This line sets the entrypoint to bash, so that we can run commands in the container.
ENTRYPOINT /bin/bash startx-once.sh Helps start the X server. I am using the Xvfb command to start the X server. If a PID is present, and when something is wrong with the X server, I can kill the process and start it again. I experimented  with blocking X sessions from network, while it may be unnecessary, i am still adding it anyway: -nolisten tcp discussion on super user #!/bin/bash
FILE=/opt/.x.pid
if [[ -f "$FILE" ]]; then
    echo "$FILE exist"
    echo "PID: " `cat $FILE`
else
    Xvfb -nolisten tcp $DISPLAY &
    echo $? > $FILE
fi ssh-keys.sh VNC Clients are less than ideal for copying and pasting text. This can be remedied by adding SSH keys to the container to help other hosts connect to it.  This opens up the possibility of using SSH tunnels to connect to the container. The following command was referenced from this ssh-keygen Stack Exchange Article #!/bin/bash

# Generate SSH keys
ssh-keygen -b 2048 -t rsa -f ~/.ssh/id_rsa -q -N ""
cat ~/.ssh/id_rsa >> ~/.ssh/authorized_keys If I am going to use these keys, I need the private key on my workstation. I am using the following commands to copy the private key to my host machine from docker, but there are a multitude of ways to do this. There was a good discussion around this on . Stack Overflow Finding the container ID with the : ps command docker ps Using the container ID to copy the with the : cp command # For root
docker cp <containerId>:/root/.ssh/id_rsa /target/path/on/host

# Otherwise for the user configured in the Dockerfile
docker cp <containerId>:/home/username/.ssh/id_rsa /target/path/on/host torrc This needs to be copied into the container, but is just uncommented sections from the boilerplate configuration the Tor Project provides . here # /etc/tor/torrc

## Tor opens a SOCKS proxy on port 9050 by default -- even if you don't
## configure one below. Set "SOCKSPort 0" if you plan to run Tor only
## as a relay, and not make any local application connections yourself.
SOCKSPort 9050 # Default: Bind to localhost:9050 for local connections.
#SOCKSPort 192.168.0.1:9100 # Bind to this address:port too.

## Uncomment this to start the process in the background... or use
## --runasdaemon 1 on the command line. This is ignored on Windows;
## see the FAQ entry if you want Tor to run as an NT service.
RunAsDaemon 1

## The port on which Tor will listen for local connections from Tor
## controller applications, as documented in control-spec.txt.
ControlPort 9051

## If you enable the controlport, be sure to enable one of these
## authentication methods, to prevent attackers from accessing it.
#HashedControlPassword 16:872860B76453A77D60CA2BB8C1A7042072093276A3D701AD684053EC4C
CookieAuthentication 1 TorBrowser.Dockerfile This Dockerfile builds on the previous Dockerfile, and adds Tor Browser and Python to the mix. I am using the package to install Tor Browser. torbrowser-launcher # From the base Dockerfile:
FROM excitingtheory/kalilinux-xvfb

ARG DISPLAY_NUMBER=1
ENV DISPLAY=:$DISPLAY_NUMBER

# More info about torbrowser-launcher:
# https://github.com/micahflee/torbrowser-launcher
RUN apt-get update -y -q \
  && apt-get install -y -q torbrowser-launcher python3 python3-pip

# Create a user and add them to the sudo group, sudo still TBD but leaving for now, will not be able to switch users in this container.
RUN useradd -s /bin/bash -m username \
  && usermod -aG sudo username

# Install python packages
RUN pip3 install selenium pytest
COPY torrc /etc/tor/torrc

# Set the user and home directory for the container
USER username
ENV USER=username
ENV HOME=/home/username

# Run the shell scripts that start the X server, and generate the SSH keys.
RUN /opt/startx-once.sh
RUN /opt/ssh-keys.sh

# This line sets the entrypoint to bash, so that we can run commands in the container.
ENTRYPOINT /bin/bash TorBrowser-root.Dockerfile Just like before but with less configuration. Will use the root user. # From the base Dockerfile:
FROM excitingtheory/kalilinux-xvfb

ARG DISPLAY_NUMBER=1
ENV DISPLAY=:$DISPLAY_NUMBER

# More info about torbrowser-launcher:
# https://github.com/micahflee/torbrowser-launcher
RUN apt-get update -y -q \
  && apt-get install -y -q torbrowser-launcher python3 python3-pip


# Install python packages
RUN pip3 install selenium pytest

# Copy the tor config file into the containera
COPY torrc /etc/tor/torrc

# Run the shell scripts that start the X server, and generate the SSH keys.
RUN /opt/startx-once.sh
RUN /opt/ssh-keys.sh

# This line sets the entrypoint to bash, so that we can run commands in the container.
ENTRYPOINT /bin/bash .github/workflows/main.yml The Github Actions workflow file builds the Docker image and pushes it to Docker Hub. This is the stock workflow from , with additional tags being pushed. I added a to trigger this Action once a day. Docker's documentation schedule name: docker build and push

on:
  push:
    branches:
      - "main"
  schedule:
      - cron:  '20 16 * * *'

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      -
        name: Checkout
        uses: actions/checkout@v3
      -
        name: Login to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
      -
        name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2
      -
        name: Build and push base image
        uses: docker/build-push-action@v4
        with:
          context: .
          file: ./Dockerfile
          push: true
          tags: excitingtheory/kalilinux-xvfb:latest
      -
        name: Build and push torbrowser root image
        uses: docker/build-push-action@v4
        with:
          context: .
          file: ./TorBrowser-root.Dockerfile
          push: true
          tags: excitingtheory/kalilinux-xvfb:torbrowser-root
      -
        name: Build and push torbrowser image
        uses: docker/build-push-action@v4
        with:
          context: .
          file: ./TorBrowser.Dockerfile
          push: true
          tags: excitingtheory/kalilinux-xvfb:torbrowser Using the Containers Now I can test out the containers and see if they work. I am going to use the tag for this example. torbrowser Building the Containers (Optional) See the for more information about the command. To build containers locally I use the following commands, otherwise they can be pulled from Docker Hub on demand during the next steps. Docker CLI Build Documentation docker build docker build -t excitingtheory/kalilinux-xvfb .
docker build -t excitingtheory/kalilinux:torbrowser -f TorBrowser.Dockerfile .
docker build -t excitingtheory/kalilinux:torbrowser-root -f TorBrowser-root.Dockerfile . Running the Containers with a Volume I need to mount a volume to the container so I can access the files that I am working on. I am using the directory as a volume. ${HOME}/src Some brief notes on the flags that we are using are included below, otherwise see the for more information about the command. Docker CLI Run Documentation docker run is used to run the container in interactive mode. -it is used to remove the container layers when it exits. --rm is used to map the port from the container to the host machine. -p is used to mount a volume from the host machine to the container. -v # Run the base container
docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb

# Run the container with the default user
docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb:torbrowser

# Run the container with the root user
docker run -it --rm -p 5901:5901  -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb:torbrowser-root Using Tor Browser from the Container Next I want to open the user container, login through VNC, and run the Tor Browser Launcher to verify that everything is working so far. Tor browser launcher won't work with the root user. Start the container with the default user: docker run -it --rm -p 5901:5901 -v "${HOME}/src":/src excitingtheory/kalilinux-xvfb:torbrowser Starting the VNC server in the container, the server will prompt for the main password, I am setting an additional view-only password. /opt/start-vnc-server-once.sh Below is an example of the output. Connect on macOS The connect to server dialog can be found from the finder menu: -> . Go Connect to Server Once the dialog is open, enter the address and click . I have saved this address as a favorite for easy access. vnc://localhost:5901 Connect Connect on Windows A vnc client like TightVNC can connect to this on . localhost:5901 Connected to Kali Linux Xfce4 Desktop Once connected, I can see the xfce4 desktop. Now I can start the Tor Browser Launcher from the terminal in the VNC session. torbrowser-launcher Once the browser is open, I can check to see if it is working by going to the Tor Project Connection Checker An example of a successful test: I opened the site on my host machine, that wasn’t connected, to compare: Progress so Far This is the Operating System setup I wanted to finish before I started working with Selenium and Python. To recap, I have done the following: Installed dependencies for Selenium, Python, and a simple xfce4 desktop environment. Built and pushed three interdependent Docker images with GitHub Actions. Successfully started a VNC Server in a Docker container. Connected to a running container's desktop environment with a VNC client. Tested out running Tor Browser Launcher from the container, and verified it is connecting to the Tor network. Now that there is a working container environment. Check out the next post in this series on covert Python web scraping.

Use Kali Linux Docker Containers to Support Covert Web Scraping

কভার ওয়েব স্ক্র্যাপিং সমর্থন করতে কালি লিনাক্স ডকার কন্টেইনার ব্যবহার করুন

Verwenden Sie Kali Linux Docker-Container, um verdecktes Web Scraping zu unterstützen

Utilice Kali Linux Docker Containers para admitir Web Scraping encubierto

Utiliser les conteneurs Kali Linux Docker pour prendre en charge le grattage Web caché

गुप्त वेब स्क्रैपिंग का समर्थन करने के लिए काली लिनक्स डॉकर कंटेनर का उपयोग करें

Kali Linux Docker コンテナを使用して秘密の Web スクレイピングをサポートする

Kali Linux Docker 컨테이너를 사용하여 은밀한 웹 스크래핑 지원

Use Kali Linux Docker Containers para oferecer suporte à raspagem secreta da Web

Gizli Web Scraping'i Desteklemek için Kali Linux Docker Konteynerlerini Kullanın

Sử dụng Bộ chứa Docker Kali Linux để hỗ trợ Quét web bí mật

使用 Kali Linux Docker 容器支持隐蔽的网页抓取

Stories, News & Mentions about BUILDX

Buildx’s Stories on HackerNoon