fabiochiu/medium-articles huggingface dataset:
Case Study on Kubernetes: Spotify
By: Gaurav Gupta
Tags: Spotify, Containers, Orchestration, Kubernetes, Technology

Let’s see what is Kubernetes?

In simple language, Kubernetes is an open source tool for automating container deployment, scaling, and management.

Google open-sourced the Kubernetes project in 2014. Kubernetes combines over 15 years of Google’s experience running production workloads at scale with best-of-breed ideas and practices from the community.

Why we need Kubernetes and what it can do?

Containers are a good way to bundle and run your applications. In a production environment, you need to manage the containers that run the applications and ensure that there is no downtime. For example, if a container goes down, another container needs to start. Wouldn’t it be easier if this behavior was handled by a system?

That’s how Kubernetes comes to the rescue! Kubernetes provides you with a framework to run distributed systems resiliently. It takes care of scaling and failover for your application, provides deployment patterns, and more. For example, Kubernetes can easily manage a canary deployment for your system.

In today's era, almost all companies(no matter big or small) using Kubernetes for managing their production environment in a much better way.

Spotify is one of those companies which early adopt container technology and then migrating from Homegrown Orchestration to Kubernetes.

An early adopter of microservices and Docker, Spotify had containerized microservices running across its fleet of VMs with a homegrown container orchestration system called Helios.

They say that one of the major risks is migrating from local fleet to Kubernetes so to mitigating the risks, they run helios alongside too.

But another plus is Kubernetes fit very nicely as a complement and now as a replacement to Helios. During the migration, the services run on both, so we’re not having to put all of our eggs in one basket until we can validate Kubernetes under a variety of load circumstances and stress circumstances.

One of the main power of Kubernetes is its vast open source community. By which “It’s been surprisingly easy to get in touch with anybody we wanted to, to get expertise on any of the things we’re working with. And it’s helped us validate all the things we’re doing.” -JAMES WEN, SITE RELIABILITY ENGINEER, SPOTIFY

Success Story:

Their success story that’s come out of the early days of Kubernetes is a tool called Slingshot that a Spotify team built on Kubernetes. “With a pull request, it creates a temporary staging environment that self destructs after 24 hours,” says Chakrabarti, DIRECTOR OF ENGINEERING, INFRASTRUCTURE AND OPERATIONS, SPOTIFY. It’s all facilitated by Kubernetes, so that’s kind of an exciting example of how, once the technology is out there and ready to use, people start to build on top of it and craft their own solutions, even beyond what we might have envisioned as the initial purpose of it.

Thanks for reading :)
Kubernetes: Service Proxy
By: Karan Gupta
Tags: Orchestration, Kubernetes, Containers, Container Orchestration

Ok great! Now that we have established that all requests for all clients in some form or the other hits ClusterIP, we just need to understand how the request finally get routed to the appropriate pod. In the above diagram, which one of those three green dots gets the request?

Perhaps there is one another burning question one might ask is “Why do you even need this? Why don’t we simply go round robin from ClusterIP (from iptables for example) to pods directly?” Kubernetes justifies it here.

Every node in the Kubernetes cluster run a container called kube-proxy . kube-proxy is a container that is responsible to provide proxy service to all your service requests. What we need to do here is just help kube-proxy send the requests to the right pod by setting some settings when spinning up our services. These settings are distinguished by the type of proxy mode kube-proxy is running under.

To understand which proxy mode to use over the other I found this blog very helpful.
Europe Aerosol Container Market Worth $1.37 Billion By 2022
By: Rajesh Varma
Tags: Europe, Aerosol, Containers

Europe aerosol container market is expected to reach USD 1.37 Billion by 2022, according to a new report by Grand View Research, Inc. Europe aerosol container is expected to witness substantial growth over the forecast period owing to its widespread use in household, paint, and medical industries. Furthermore, growing demand for these products from food & beverage and automotive applications is expected to propel market growth over the projected period.

Increasing demand for cosmetic products in countries including UK, France, Germany and Italy is expected to have positive impact on market growth. Furthermore, rising demand from personal care sector owing to increasing use of deodorants, hair sprays, and shaving creams among young population is expected to be a key driver for aerosol container market growth.

To request a sample copy or view summary of this report, click the link below:

www.grandviewresearch.com/industry-analysis/europe-aerosol-container-market

Further key findings from the report suggest:
Building Docker Images — Advanced
By: Pascal Euhus
Tags: Cicd, Containers, Development, Docker, DevOps

Building Docker images the legacy way

Consider we have the following Dockerfile to build our container

Dockerfile for Ansible container with AWS CLI

We will use python:3.9.1-buster as base for our image here, because it already includes neccessary binaries like git, openssh . There are 5 Layers in total. We can now build our container issuing the command:

docker build -t ansible --no-cache .

Take note of the --no-cache to prevent caching, as we want to meassure the time it takes to build the image. Omiting this param will enable Dockers caching mechanism and we wont be able to have a comparable result. Typically you wont make use of --no-cache in a normal build.

The results of our build command are:

Files sent to build Context: 325.1 MB

Build time: 4:35 minutes

Image size: 1.34 GB

Recap:

The Docker build context is quite huge, because it includes bigfile.txt , even though it is not needed for the build. This is quite common as you might have frontend and backend sources together in a repository, but different Dockerfiles to build a container for backend and another for frontend. However if you exclude bigfile.txt in .dockerignore it won’t be available in both frontend and backend build context.

The image size is huge as well, because the base image is python:3.9.1-buster which has an initial size of ~324 MB and contains all dependencies from the Ansible installation.

The build took 4:35 minutes and was sequencially, even though the installation tasks could have been hypothetically executed in parallel.
Kubernetes: Services
By: Karan Gupta
Tags: Orchestration, Kubernetes, Containers

Let’s step back a little.

When you are working with Docker Swarm or simply using docker-compose one notices how the world is so beautiful. When you do a stack deploy or docker-compose up the DNS names are by default the name of your containers mentioned in your yml files. 😃

http://nginx:8080

When you are learning Kubernetes and come ample amount of time with swarm and compose, it can be quite confusing what to expect from Kubernetes. Especially when you’re a developer and need to “creates services” in it. When you created that application listening to requests on port 8080 (for example) inside that container which is inside of that pod, you need to be able to make a request to it. I mean that’s what a service is!

Problem

However, the pod you create have it’s own IP address. This IS the problem. Pods created using deployments have dynamic ips. Perhaps the node was running out of memory or someone accidentally spilled coffee on that worker node. In that situation, ReplicaController will create a new instance of the pod in another running node. This new pod will have a new IP address. If an another application of mine is using this application in the pod, wouldn’t it be nice if I didn’t have to change my application to point to the new pod address and it simply just was resilient to those types of issues?

Official doc states

While the actual Pods that compose the backend set may change, the frontend clients should not need to be aware of that, nor should they need to keep track of the set of backends themselves.

Service

Kubernetes is new to me and so far my learning process has been around services mostly that I feel needs a bit of slowing down (and meditating). I think once we can demystify the workings of services in the Kubernetes scope and understand the “why” behind it, it will hopefully help me make better decision about when to use it.

A service is a stable ip address over a set of pods. This ip address will NEVER change unless it goes down. Moreover, these pods run containers (applications) that provide the same functionality. The functionality is provided in form of requests listened on ports inside the containers. Once you hit the service with the request, service abstraction simply responds back with your appropriate response.

Conclusion

The very nature of Kubernetes service of unchanging IP address (or service DNS name) makes it alluring when it comes to providing better resiliency, transparency, and availability of your service — make a request and get a response with pod faulterance. Now let’s look at how your requests are routed to the pods.
running Java in container with UseContainerSupport
Tags: Containers, Ci Cd Pipeline, Docker, DevOps, Misc

in this experiment, I will spawn a docker image from a ubuntu box with 32 gb memory.

$ cat /proc/meminfo

MemTotal: 32917068 kB

we tried to allocate 1 GB memory to the container and print out the actual max heap from within container JRE,

openjdk:8u131 doesn’t have the UserContainerSupport feature,

— so it doesn’t recognise the 1 GB resource limit allocated to the container;

— how does it decide with the 6.98G limit? by default, Java 8 will allocated 25% of host physical memory as -xmx, so over here, 25% x 32GB = 8 GB.

$ docker run -m 1gb openjdk:8u131 java -XshowSettings:vm -version

WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.

VM settings:

Max. Heap Size (Estimated): 6.98G

Ergonomics Machine Class: server

Using VM: OpenJDK 64-Bit Server VM openjdk version "1.8.0_131"

OpenJDK Runtime Environment (build 1.8.0_131-8u131-b11-2-b11)

OpenJDK 64-Bit Server VM (build 25.131-b11, mixed mode)

now using a later JDK image with UseContainerSupport support,

$ docker run -m 1g openjdk:8u191-jre-alpine java -XshowSettings:vm -version

WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.

VM settings:

Max. Heap Size (Estimated): 247.50M

Ergonomics Machine Class: server

Using VM: OpenJDK 64-Bit Server VM openjdk version "1.8.0_191"

OpenJDK Runtime Environment (IcedTea 3.10.0) (Alpine 8.191.12-r0)

OpenJDK 64-Bit Server VM (build 25.191-b12, mixed mode)

here, the JRE in the container is allocated 25% of the memory allocated to the container instance (25% x 1GB = 250m).
So it begins…. Our story of how Jora came about and…
Tags: Containers, J2ee, Java, Cloud Computing, Web Applications

Last year, we were looking to deploy our new Java web application somewhere without building a complete infrastructure, without going through many pages of configuration on a cloud vendor’s console, without worrying about whether we missed something important. We thought we could find a provider that would make it …. how to say it …easy…no-hassle…smooth…fluid.

After trying a few, we realized it is not that trivial to find one. So what to do? Do it ourselves!

Based on experience working with Java app servers and containers, we thought we could launch a Java Container Service of some sort. Where people like us, who had the same problem we had, with a simple WAR file in the had, could just…do it!

So we launched Jora. You have 5 minutes? Come visit us at JoraHub.

We know we have a long way to go. We know this is just an MVP to start. Honestly it has much more features than it should which we kind of regret — we should have launched with a crappier product ;)

So you have a Java web application, a WAR file or two in hand, just give it a try. And please let us know about your experience. We sincerely would appreciate your feedback more than anything at this point.

Thanks for checking us out!
Running GUI Apps inside Docker Container
By: Anshika Sharma
Tags: Containers, Gui App, Docker Container, X Server, Network Drive

Architecture of this task

IT industry is focusing on Time saving and creating such technologies that can work smartly and fast. One of such technology is Docker that is a containerization tool.

There are two types of Applications or services can be used inside a Docker Container, that are:

Applications that run as a Background Services(like webserver). GUI Applications that runs in Foreground

For a GUI Application to run, we need to have a XServer which is available as part of every Linux Desktop Environment, But within a Container we don’t have any XServer, so we will
Kubernetes: Services Types
By: Karan Gupta
Tags: Orchestration, Kubernetes, Containers

How your requests are routed to the pod is the question we are going to solve now. Perhaps, instead of “how” maybe we should ask “who” first. Who is actually trying to connect to your services? And since that question would really help us answering the one and only question — what is my service type? Who is it going to serve?

ClusterIP

If your clients are always going to be internal — aka pods inside the kubernetes cluster, then you need to create a service of type ClusterIP. As the official doc states, it exposes the Service on a cluster-internal IP. Choosing this value makes the Service only reachable from within the cluster. This is the default ServiceType .

NodePort

If your clients are outside of the cluster, then you need to use a NodePort type. As the official doc states, it exposes the Service on each Node’s IP at a static port (the NodePort ). A ClusterIP Service, to which the NodePort Service routes, is automatically created. You'll be able to contact the NodePort Service, from outside the cluster, by requesting <NodeIP>:<NodePort> .

LoadBalancer

If your clients sending requests from external load balancer sitting in a cloud provider, say AWS, then you need to use LoadBalancer type. This type actually automated the configuration process of setting the configs of the AWS load balancer — aka Kubernetes displaying how it can manage to automatically configure that for you on your cloud! As the official doc states, it exposes the Service externally using a cloud provider’s load balancer. NodePort and ClusterIP Services, to which the external load balancer routes, are automatically created. To be precise, the cloud provider load balancer actually sends requests to <NodeIP>:<NodePort> which was all set automatically.

The above diagram depicts the overall request routing structure. We can see for all the clients above, the other two separate K8 clusters, your laptop, and your cloud load balancer, all the requests are finally being routed from ClusterIP.

Now that we have simplified the the routing structure a bit the only part of the puzzle left is the communication from ClusterIP and the pods — which pod gets the request? 🤔
Container in flutter..
By: Satheesh Guduri
Tags: Flutter, Container, Padding, Widget, Margin

for a widget you need to add some background color, style or size etc..then just wrap your widget with the Container.

for example, simply we take one widget as Text(“hello”), this widget simply draws the text on screen as hello.

When you wrap with container like Container( color:Colors.blue, child:Text(“hello”)) now it shows some background color to it. In the same way container has so many properties we discuss here one by one.

Padding:

The blue color background is nothing but container and we added some padding to the widget. padding means it leave some space in the container, for example if you are giving top padding means top side it leaves the space comes down side.

Margin:

when your widget wraps with the container, you can use margin to maintain some distance to another widgets.

Decoration:

The decoration property allows to change the border color and and also border radius. And also we can change the shape of the container like shape:BoxShape.circle

Alignment:

you can align your child widget like left, right or center..

alignment: Alignment.center

Height & Width:

You can add specific width and height for a container, if you are not giving these values it will takes child width and height by default.

Gradient:

by using gradient property you can add two colors to the container and the color from left to right getting lighter.

gradient: LinearGradient( begin: Alignment.centerleft, end:Alignment.centerright, colors:[ Colors.blue,Colors.lightblue])

If you like my article, please clap for me, you can clap 50 times also..
How to Actually Deploy Docker Images Built on M1 Macs With Apple Silicon
By: Jon Vogel
Tags: Containers, Apple, Docker, Apple Silicon, Programming

Use buildx

Buildx comes with a default builder that you can observe by typing docker buildx ls into your terminal. However, we want to make and use a builder ourselves.

Make a builder

You will need a new builder, so make one with docker buildx create --name m1_builder . Now you should see the new builder when running docker buildx ls .

Use and bootstrap the builder

The next steps are to “use” the new builder and bootstrap it. Start with docker buildx use m1_builder and then docker buildx inspect --bootstrap , which will inspect and bootstrap the builder instance you just started using. You should see something like this:

computer@computer-m1 ~ % docker buildx inspect — bootstrap [+] Building 5.3s (1/1) FINISHED => [internal] booting buildkit 5.3s => => pulling image moby/buildkit:buildx-stable-1 3.1s => => creating container buildx_buildkit_m1_builder0 2.3s Name: m1_builder Driver: docker-container Nodes: Name: m1_builder0 Endpoint: unix:///var/run/docker.sock Status: running Platforms: linux/arm64, linux/amd64, linux/riscv64, linux/ppc64le, linux/s390x, linux/arm/v7, linux/arm/v6

You can see that this builder has a whole host of platforms it will build for!

Build with the builder

Now, cd your terminal into a place where you want to build and push an image so you can run this pseudo-command:

docker buildx —-platform linux/amd64,linux/arm64,linux/arm/v7 -t <remote image repository> --push .

You should see the “in use” builder go crazy and build the architectures you specified.

If you wan’t the skinniest possible build you will need to know the architecture you are deploying to. In my case my AWS ECS tasks required linux/amd64 which is the only option I use after the --platform flag.

Manifest

Once your image has been built and pushed, you can inspect the manifest with:

docker buildx imagetools inspect <remote image repository>

You should see a manifest printout with all your different architectures. Most services that pull an image are smart enough to know which architecture to go get.

Clean up

Finally, as you might have experienced, Docker can start to take up a bit of disk space. If you did not use buildx , you probably ran docker system prune --all , the equivalent for buildx is luckily semantically similar.

docker buildx prune --all

That’s it! Happy container development!
Life without Docker 🐳
By: Benjamin Swerdlow
Tags: M1, Containers, Kubernetes, Docker, Mac

I miss Docker 💔

Image by Jacob Zwang

A few weeks ago I traded in my old 2016 Macbook for a sleek new 2020 Macbook. Apple was not lying when they said the performance on the M1s is amazing. On my first day with my new computer, the only thing I used was Flutter, which worked great. However, soon I ran into one problem: I could not run Docker. At the time I got my computer, Docker for the Mac M1 was not available in any form, and even now it is only available in developer preview.

For me, losing Docker was like being forced to go from Google Docs to Notepad. I started working with the backend when Docker and serverless were already mainstream, and I never realized everything Docker did for me until it was gone.

One of my main projects uses a PostgreSQL database for persistent storage, along with a Redis cluster for short term recommendation storage, and 4 different microservices (two written in Rust, two in JavaScript). With Docker, I had these all set up in a docker-compose file and could bring them all up or down with docker-compose up --build and down with docker-compose down . I had no idea how painful the process of getting this architecture working without Docker is. Configuring a local PostgreSQL database is surprisingly hard, especially when you have to apply the migrations every time because of multiple projects. Losing Docker made me take a step back and think about the benefits of simple systems. I set up my project twice before deciding that I was going to have to postpone the project until I could use Docker.

Recently I saw the light at the end of the tunnel. Docker released their developer preview🥳🥳🥳! I joined their developer preview program the day they offered it and downloaded it as soon as it was available. The new Docker on Mac M1 is far from complete, but it feels great to have it. I am back to my old ways of having 4 PostgreSQL databases hosted, and dozens of microservices at a time.

Docker opens up a whole new world for development. The powerful microservice architectures we build today are only possible because of it, which is why I would like to say thank you to the Docker team.
[ CKA-I ]-Certified Kubernetes Administrator Sınavı Hazırlık Serisi
By: Serkan Bingöl
Tags: Containers, Awscertr K8s, Kubernetes, DevOps, Turkish

Learn more. Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Make Medium yours. Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore
Deploy Spring Boot Application on Kubernetes
By: Ashish Choudhary
Tags: Containers, Kubernetes, Docker Desk, Docker, Spring Boot

How to Monitor and Manage Kubernetes Cluster with Lens IDE

Lens IDE for Kubernetes is a desktop application for macOS, Windows, and Linux to manage your cluster. It’s completely free and open source. You can download it from here. Developers, DevOps engineers, SRE, and also people who are learning Kubernetes on their laptops can use this to view and manage their clusters. Following are some of the highlighted features that it provides.

Manage multiple clusters with a single IDE.

360-degree view of your cluster.

Prometheus integration

Context-aware built-in terminal

Built-in support for managing Helm charts

After installing it you can first add a cluster. Lens connects to your Kubernetes cluster using the kubeconfig file which is typically located in your $HOME/.kube directory. You have the option to paste it as a text file also. Now select the kubeconfig file, context, and click on Add cluster.

Add a cluster to Lens IDE

After adding the cluster you can see it on the left side navigation bar. For demo purposes, I have redeployed the Spring Boot application. Under events, you can see that our application image is getting pulled.

Kubernetes Cluster Overview

We can also view the logs of the deployment we just completed. As you can see that application is deployed and running.

Spring Boot Application logs

You can scale, restart, edit and remove Kubernetes manifests from Lens IDE itself.

View Deployments

Under networks, you can also view Kubernetes services.

View Services

Lens has a feature where it allows you to install Prometheus stack in your cluster so that you can gather metrics about the cluster and its nodes. For installation, right-click on the cluster icon in the Lens UI’s top-left corner and select Settings.

Lens Settings

On the Settings page, under features, you can see a Metrics section and a button to install Prometheus. Click Install to deploy the Prometheus stack to your cluster.

Install Prometheus

Lens will start displaying metrics after a minute or so.

Prometheus metrics

We have only covered a handful of features that Lends IDE for Kubernetes provides. It’s a wrap for now.
Docker in Software Development
By: Figo Muhammad
Tags: Containers, Tutorial, Servers, Docker, Software Development

How to use it?

Install the Docker Engine

The method of installing the Docker Engine is different in every operating system. I recommend you to follow the guide made by Docker. I am going to Ubuntu 18.04.5 for this article. Keep in mind that some commands may differ if you are using other than Ubuntu 18.04.5.

As you can see, I have installed the Docker Engine on my PC. I ran sudo docker run hello-world and the message is shown. This means that the installation is succeeded.

Make a Dockerfile file inside your repository

To build the Docker image, you have to make a file name Dockerfile as the place to define the steps in building the image.

These are the content of my Dockerfile as I am currently developing a ReactJS application. The content of the Dockerfile should be adjusted to your own application.

These are several explanations of the commands above:

FROM : This command specifies the parent image as the base of your Docker image.

: This command specifies the parent image as the base of your Docker image. RUN : This command executes a command inside the parent image.

: This command executes a command inside the parent image. WORKDIR : This command sets the working directory for any RUN , CMD , ENTRYPOINT , COPY , and ADD commands that follow this command in the Dockerfile .

: This command sets the working directory for any , , , , and commands that follow this command in the . COPY : This command copies new files or directories from <src> and adds them to the filesystem of the container at the path <dest> .

: This command copies new files or directories from and adds them to the filesystem of the container at the path . CMD: This command executes the given command whenever you run the image. So, the RUN command is executed in the building process and CMD is executed whenever you run sudo docker run command.

There are other commands such as ENTRYPOINT, EXPOSE, etc. You can learn more about them on the internet.

Build the Docker image

We can build the Docker image using sudo docker build -t <image-name> command. -t argument is used to enable us to fill in the image name. My image name is praktikum-frontend . The building process consists of the steps that we have defined in Dockerfile.

Next, we can check whether the image has been built using sudo docker images command.

As you can see, our new image has been created.

Test the image

After building the image, we can run the image using sudo docker run <image-name>

Summary

Docker is a tool that is very beneficial for software developers and system administrators. Docker makes the deployment and scaling process much faster. I recommend you to learn more about Docker and use it for your next project.

Thank you!

References
Sharing Windows Folders for Containers
By: Huseyin Elci
Tags: Folder Sharing, Container, Docker, Windows 10, File Sharing

Docker users know, when you delete or come off from a container, you made all the changes on the container are also removed. This made all the changes must be protecting and saving before deleting or coming off. You should transfer your changes to a safe place to your cloud or your local.

Docker containers are completely isolated from Windows or MacOS systems. If you want to have configuration files or other assets remain persistent, or all the changes must be protected, for this try mounting Windows folders on containers.

Let’s get started then. You must follow these steps to make setting:

Setting General Resource

Setting

Docker Desktop menu allows you to configure your Docker settings such as installation, updates, version channels, Docker Hub login, and more. We have to go Setting too.

Open the Docker Desktop menu by clicking the Docker icon in the Notifications area and select Settings to open the Settings dialog:

General

On the General tab of the Settings dialog, you can configure when to start or update Docker. (I will not talk about them as they are not the subject of this post.) We have to do the first settıng here.

Attention:

The File sharing tab is only available in Hyper-V mode, because in WSL 2 mode and Windows container mode all files are automatically shared by Windows.

Resources

The Resources tab allows you to configure CPU, memory, disk, proxies, network, and other resources. Different settings are available for configuration depending on whether you are using Linux containers in WSL 2 mode, Linux containers in Hyper-V mode, or Windows containers.

You should use ‘File sharing’ to allow local directories on Windows to be shared with Linux containers. This is especially useful for editing source code in an IDE on the host while running and testing the code in a container. ?Note that configuring file sharing is not necessary for Windows containers, only Linux containers. If a directory is not shared with a Linux container you may get a file not found or cannot start service errors at runtime.

File share settings are:

Click + and navigate to the directory you want to add for adding your directory.

Apply & Restart makes the directory available to containers using Docker’s bind mount (-v) feature.

That’s it.

If you want additional information for sharing or advanced settings please visit Docker documentary. Click it.
Best Storage Container for Clothes — gadgetszone.in
By: Gadgets Zone
Tags: Storage, Clothes, Containers, Storage Containers

Description

Product Details :

1. Size : 40 x 40 cm. , Color : Blue

2. Design : After the folding locker is opened, it is a small cabinet that can be placed. After folding, it is a mural, which can be opened in 1 second. A variety of small cabinets can make the bathroom more tidy.

3. Material : The cabinet is made of resin and ABS plastic. The thick and wear-resistant material makes the wardrobe more powerful.

4. Function : It adopts environmentally-friendly plastic material, super waterproof function, placed in the bathroom, can be placed in clothes, not afraid of clothes.

5. Device : The punch-free design makes the mural cabinet more practical and not easy to fall off, and it will not damage the integrity of the wall.

Durable and waterproof：This product is tough, Bearing strong. This product uses high quality materials,100% waterproof, ideal for using in the humid environment.

Easy to Install and Punch free: No complicated processes required, and it can be installed by ordinary methods, saving time and effort.

Healthy and Lead-free: This product uses healthy and environmentally friendly materials that will not harm your body and are very beneficial to children’s health

Careful Design: carefully designed by excellent designers, beautiful appearance, space saving, can make your bathroom neat and orderly

Package Included : 1 Pcs Of Folding Bathroom Storage container
RUN GUI APPS IN A DOCKER CONTAINER
By: Manali Jain
Tags: Firefox, Containers, Docker, Technology News, Technology

DOCKER — Docker is a container Technology and it installs + boot + login into a device in just a few seconds. Docker just opens a terminal it does not open a GUI Interface.

In this article, I am going to show how docker is opening GUI software like firefox and gedit.

Pre-requisites -

Docker already Installed on BaseOS.

Run the Docker Container -

>> docker run -it — name firefox — net=host -e DISPLAY=$DISPLAY -v /tmp/.X11-unix centos:7 bash

— name:- Assign a name to the container

— net:- Connect a container to a network

-e:- set environment variables

-v:- Bind a Volume

“ docker run ” first create a container and then start it.

first create a container and then start it. “ host ” network mode gives IP of Host not the IP of Docker Host.

network mode gives IP of Host not the IP of Docker Host. “ X11 ” server communicates with clients like xterm, firefox, etc via some kind of reliable stream of bytes. For Example — if you run a container that binds to port 80 and you use host networking, the container’s application is available on port 80 on the host’s IP address.

INSTALL FIREFOX AND XAUTH

>>yum install firefox xauth -y

The above is the command to install firefox and the xauth program.

The “ xauth ” program is used to edit and display the authorization information used in connecting to the X server. This program is usually used to extract authorization records from one machine and merge them into another (in the case when using remote logins or granting access to other users).

program is used to edit and display the authorization information used in connecting to the X server. This program is usually used to extract authorization records from one machine and merge them into another (in the case when using remote logins or granting access to other users). Firefox is a GUI Browser.

INSTALL GEDIT

>>yum install gedit

The above is the command to install gedit which is a Graphical User Interface Editor.

Thank You for reading have a good day!!
Reverse engineering a docker image
By: Sambhav Jain
Tags: Containers, Command Line, Reverse Engineering, Docker, Linux

We all know that docker is a great tool to build and deploy applications. However, it is rather difficult to get the source code of a 3rd party image as a developer. In this guide, I will attempt to clone the source code of a downloaded image from a remote server.

There are some things to keep in check in case you come across such:

Inspecting a docker image:

sudo docker image inspect <IMAGE_NAME>

This command will provide the image configuration in JSON with one crucial detail to look for i.e., where the actual code of the image resides within it. Look out for WorkingDir under ContainerConfig and that will be the root of the source code being run by the image.

For Example:

Cloning a docker image

# Create a new temporary image from the existing docker image

$ sudo docker create — name=”tmp_$$” <IMAGE_NAME:TAG> # Export the temporary image to a tarball

$ sudo docker export tmp_$$ > image.tar # Delete the temporary image

$ sudo docker rm tmp_$$ # Let’s use sftp to download the tarball to our local machine

$ sftp -i <KEY> <USERNAME>@<SERVER_NAME>

$ get image.tar # Now once you have the tarball downloaded to you local machine, extract and navigate to the WorkingDir highlighted earlier, which here was 'var/apps/app-name/'

$ cd /Downloads/<EXTRACTED_IMAGE_FOLDER_NAME><WorkingDir>

And there you have it, the source code of a 3rd party image.

Things to consider before attempting this:
Containers Security Methodologies
By: Michael Hidalgo
Tags: Containers, Container Security, Application Security, Standardization

A mind mapping approach for implementing secure applications

Photo by Lucas van Oort on Unsplash

As I had the great opportunity to talk a little bit about containers security in the Open Security Summit, I wanted to share with you some mind maps that we created to summarize different mythologies and standards that the Security team can use as a reference when building applications that will run on a containerized environment.

1. OWASP Container Security Verification Standard

As described in the OWASP Web Site “The Container Security Verification Standard (CSVS) is a community-effort to establish a framework of security requirements and controls that focus on normalizing the functional and non-functional security controls required when designing, developing and testing container-based solutions with a focus on Docker”.

Definitely, CSVS is a great framework to help us to design and implement applications in containers. Here is the mind map of this standard with the múltiple stages it has:
Windows Containers — An Overview !
By: Arun Kumar Singh
Tags: Containers, Windows, Windows Containers, Linux, Virtualisation

TECH BASICS

A container is an isolated, lightweight system for running an application or process on the host operating system. If you talk about containers, you should start with LXC always. Technically that was the first proper implementation of containers. This whole magical world of containers started from Linux Kernel feature which allowed to run processes that are isolated from the rest of the system. This technology and its power gained momentum when Docker and CoreOS came with useful and easy features. Now today Docker became de-facto standard for containers deployment and management and CoreOS for Container optimised Operating Systems. LXC was the tech behind both of them.

Linux Containers give you ability to run a completely system isolated process which has its own environment. When I say own environment, I meant process namespace, file share, network etc. In simple word virtualisation at kernel layer ! But its not exactly virtualisation. And the main reason why containers are famous because you can package it and share it. This tech has simplified whole development and deployment life-cycle and gave true power to DevOps.

Container

Containers are build on top of the host operating system’s kernel so OS and Container both share same kernel. Any container who wants to access or use kernel’s feature, does not get everything on plate straightaway!

In these scenarios, usually container gets an isolated or virtualised view of kernel. That’s why, what-ever happens in Container goes away when it stops running.

In 2016, Microsoft worked with Docker to create a container engine implementing the Docker specification on windows . This allowed containers to run on windows servers as well. Windows offers two kind of isolation —
Help Shape ATT&CK for Containers
By: Jen Burns
Tags: Mitre Attack, Containers, Threat Informed Defense, Kubernetes, Docker

Written by Jen Burns

One of the questions that pops up often for the MITRE ATT&CK® team is whether or not we have considered expanding ATT&CK to cover container technologies such as Kubernetes and Docker. We’ve heard your need for coverage in this space, and we’re thrilled to announce that in partnership with the Center for Threat-Informed Defense, the ATT&CK team is now investigating adversarial behavior in containers for potential inclusion in ATT&CK. If we find that there’s enough adversary behavior in containers to warrant ATT&CK coverage, we’ll consider that content for a future ATT&CK release.

There have been some excellent efforts executed across industry to research and publish what threats and vulnerabilities may exist in technologies such as Kubernetes and Docker and how to attack and defend these and related spaces. Since ATT&CK is based on real-world “in the wild” adversary behaviors, our investigation is focused specifically on gathering intelligence on what adversaries are actually doing with these technologies versus what researchers and red teams can do.

We also understand that the definition of “containers” can be fairly vast, so at this point we’re interested in what adversaries are doing across anything related to containers. For example, we’d be interested in how they gain initial access through the orchestration layer, evade defenses within a container, move laterally across a pod, or any other technique related to the containers space.

With that in mind — we need your help! Do you have visibility or knowledge of what real adversaries are doing in any facet of the containers space and want to engage with the ATT&CK team or submit contributions? If so, please let us know at attack@mitre.org. We’re also interested in your opinions on how container-related techniques in ATT&CK should be represented. Should we just consider adding a Kubernetes matrix, for example, or should we divide the orchestration layer and container layer into separate matrices? Let us know what you think! We look forward to engaging with you, and thank you for helping us continue to improve ATT&CK for the entire community.

© 2020 MITRE Engenuity. Approved for Public Release. Document number CT0013.
How to Use Kustomize for Your Kubernetes Projects
By: Randil Tennakoon
Tags: Containers, Programming, Kubernetes, Docker, DevOps

3. Add Changes to the Existing K8s Resource Files

Changing the label of the existing Kubernetes deployment

Inside the resources section, you can add your K8s resource files, such as deployments, services, namespaces, ConfigMaps, etc. At the moment, I only have a K8s deployment. After specifying the resources , you can then move to the next section where you define your changes.

commonLabels:

someName: #some-value

owner: #mike

app: #test

The commonLabels field allows you to define labels/names to your YAML configuration file. As shown above, you can add your labels to it. Once you’re done with the changes, you can run the command below to apply them to your deployment:

$ kubectl delete -f nginx-deployment.yaml

First, you need to remove the existing pod. But before deleting the existing pod, make sure to run the kubectl get all --show-lables command to check what you have in the Labels section in your pod:

// output NAME READY STATUS RESTARTS AGE

pod/nginx-deployment 1/1 Running 0 26s LABELS

app=nginx,pod-template-hash=66b6c48dd5

Then you can apply your changes by running the command below:

$ kubectl apply --kustomize . OR $ kubectl apply -k .

Let’s run the kubectl get all --show-labels command and see whether it has taken the changes:

// output NAME READY STATUS RESTARTS AGE

pod/nginx-deployment 1/1 Running 0 9m14s LABELS

app=nginx,owner=randil,pod-template-hash=6dcc7ddc48 NAME READY UP-TO-DATE AVAILABLE AGE

deployment.apps/nginx-deployment 1/1 1 1 9m14s LABELS

app=nginx,owner=randil NAME DESIRED CURRENT READY AGE

replicaset.apps/nginx-deployment-6dcc7ddc48 1 1 1 9m14s LABELS

app=nginx,owner=randil,pod-template-hash=6dcc7ddc48

Note: If you’re running an older version of Kubernetes, you have to install Kustomize on your computer before getting to this process. Then, you can run the commands below to apply the changes.

$ kustomize build . > test-deployment.yaml $ kubectl create -f test-deployment.yaml

Changing the names of the existing Kubernetes deployment

Kustomize helps you to change the names of your K8s resource files. For that, you can use the namePrefix and nameSuffix fields:

resources:

- nginx-deployment.yaml commonLabels:

owner: randil namePrefix: test- nameSuffix: -dev

namePrefix appends your custom text at the beginning of the name and nameSuffix appends your custom text to the end of the existing name.

// output - extracted only the relevant part NAME

deployment.apps/test-nginx-deployment-dev

Refer to the docs for more options.
Flutter: Anatomy of a Container
By: Hamza Mateen
Tags: Flutter, Flutter Widget, Containers, Flutter App Development, Flutter Ui

Figure 1: Flutter Container demo

I started writing code in dart for Flutter for more than a year now. Whenever I see a tutorial, read an article or follow an instructional series for learning Flutter better, I see that Container is the widget where things start from. Container has been in my life for so long, I decided to write a little about it in its honor. In this article, I am going to break down the anatomy of a Flutter Container.

The Container widget can be used anywhere inside the widget tree. It is one of the most adjustable widget. There are many parameters of this widget which help in decorating it to your requirements.

Child

Container takes a child widget which stays inside of it. In figure 1, Text widget is provided as the child along with a Center widget to position it in the center.

Height

Takes a double value as the constant height of the Container.

Width

Takes a double value as the constant width of the Container.

Color

Fills in the Container with the desired color.

Padding

The padding parameter is applied around the child of the Container. It takes one of the many const functions of EdgeInsetsGeometry. Refer to figures 2 and 3.

Figure 2: Dart code for Container with padding

Figure 3: Container with padding 8.0

Margin

The margin parameter is applied around decoration and child. Here, I had to provide an extra Container as background to visualize the effect of margin. See figs. 4 and 5.

Figure 4: Dart code for Container with margin

Figure 5: Container with margin 8.0

Border

The border parameter is given via the BoxDecoration object. When applied, it can be seen around the child or padding, if there is any.

Figures 6 and 7 will help you better understand the difference between the three concepts of spacing.

Also, observe that when decoration is used, Container does not allow using its color parameter and instead suggests using the color parameter inside the BoxDecoration object.

Figure 6: Dart code for Container with border

Figure 7: Container with border 4.0

See figure 8 to get an idea of where padding, margin and border can be observed in a Container.

Figure 8: Breakdown of a Container. (This image was taken from a video lecture on Udemy by Maximilian Schwarzmüller)

Transform

This parameter allows the Container to move on the x, y or z axes.

Figure 9: Dart code for Container with transform property on Z axis

Figure 10: Container transformed on Z axis by 2 radians

To know more about transformations, check out my article on transformations and custom paint here.

Find more about Container through Flutter official docs here.
OpenShift Origin(OKD) on Ubuntu 18.x
By: Arun Kumar Singh
Tags: Containers, Openshift, Okd, Kubernetes, Openshift Origin

Moving to OpenShift

OpenShift origin is a free, open-source, and cloud development Platform as a Service (PaaS) developed by Red Hat. It’s a community distribution of OpenShift

In this post we will setup a quick standalone deployment using container

To use OpenShift Origin we need to Install Docker Components first.

Steps for OpenShift Origins —

Download Client Tools



wget # download openShift Client Toolswget https://github.com/openshift/origin/releases/download/v3.11.0/openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit.tar.gz

2. Untar file and move executable to bin

tar xvzf openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit.tar.gz cd openshift-origin-client-tools*/ sudo mv oc kubectl /usr/local/bin/

3. Update Docker to accept insecure registry

cat << EOF | sudo tee /etc/docker/daemon.json

{

"insecure-registries" : [ "172.30.0.0/16" ]

}

EOF # restart docker services once sudo systemctl restart docker

4. Start the cluster now
Trivy, detect and fix Docker images vulnerabilities
By: Jihad Benabra
Tags: Security, Docker, Containers

Using a Docker images to package your application has become a standard, but what about security ?

Each image use many libraries and packages as dependencies for our applications, therefore we should to be sure that this dependencies does not contain vulnerabilities.
Deploying PHP Docker containers to AWS Lambda
By: Jan Richter
Tags: Containers, Lambda, Docker, AWS, PHP

In the past few years, most full-stack developers adopted Docker as part of their day-to-day engineering process. While PHP was never an officially supported language in AWS Lambda, the new announcement from Re:Invent 2020 makes it much simpler to deploy PHP code.

This means that you can leverage the power of serverless without having to adopt new abstractions such as the Serverless framework or Lambda layers.

Bear in mind that the release is only a couple of days old and the support is limited. You can currently deploy containers to Lambda in US East (N. Virginia), US East (Ohio), US West (Oregon), Asia Pacific (Tokyo), Asia Pacific (Singapore), Europe (Ireland), Europe (Frankfurt), South America (São Paulo).

Getting started

You need to have a working AWS account (ideally with Administrator access), you will also need to have Docker, PHP, Composer and AWS CLI installed on your machine.

Pricing

Deploying cloud workloads can be tricky when it comes to costs. In this example, we will be using Lambda and ECR which shouldn’t exceed $1/month (depending on the size of your image and Lambda invocations). Nonetheless, make sure you have a budget in place.