It’s an early alpha version of the platform for SONM.io project.

For now it has lots of unfinished task. The main idea is to show that such platform can be implemented and to chose a techstack for future implementation.

This repository contains code for Hub, Miner and CLI.

A docker container contained every CLI, Miner, Hub can be found on public DockerHub: sonm/insonmnia

docker pull sonm/insonmnia

If you want it’s easy to build all the components. You need golang > 1.8:

make build

Also there is a Dockerfile to build a container:

docker build .

Look at milestone https://github.com/sonm-io/insonmnia/milestones

To start a hub it’s needed to expose a couple of ports.
10001 handles gRCP requests from CLI
10002 is used to handle communication with miners

docker run --rm -p 10002:10002 -p 10001:10001  sonm/insonmnia sonmhub

To run Miner from the container you need to pass docker socket inside and specify IP of the HUB

  docker run --net host -e DOCKER_API_VERSION=1.24 -v /run:/var/run sonm/insonmnia:alpha3 sonmminer -h <hubip:10002>

CLI sends commands to a hub. A hub must be pointed via –hub=hubip:port. Port is usually 10001.

Just check that a hub is reachable and alive.

sonmcli --hub <hubip:10001> ping
OK

List shows a list of miners connected to a hub with tasks assigned to them.

NOTE: later each miner will have a unique signed ID instead of host:port

sonmcli --hub <hubip:port> list
Connected Miners
{
	"<minerip:port": {
		"values": [
			"2b845fcc-143a-400b-92c7-aac2867ab62f",
			"412dd411-96df-442a-a397-6a2eba9147f9"
		]
	}
}

To start a container you have to pick a hub and miner connected to that hub.
You can pick a miner from output of List command. See above.

./sonmcli --hub <hubip:port> --timeout=3000s  start --image schturmfogel/sonm-q3:alpha  --miner=<minerhost:port>

The result would look like:

ID <jobid>, Endpoint [27960/tcp-><ip:port> 27960/udp-><ip:port>]

• jobid is an unique name for the task. Later it can be used to specify a task for various operations.
• Endpoint describes mapping of exposed ports (google for Docker EXPOSE) to the real ports of a miner

NOTE: later STUN will be used for UDP packets and LVS (ipvs) or userspace proxy (like SSH tunnel) for TCP. Miners who have a public IPv4 or can be reached via IPv6 would not need this proxy. The proxy is intended to get through NAT.

To stop the task just provide the jobid

sonmcli --hub <hubip:port> stop <jobid>

Dockerfile for the image should follow several requirements:

• ENTRYPOINT or CMD or both must present
• Network ports should be specified via EXPOSE

Technologies we use right now:

• golang is the main language. Athough golang has disadvantages, we believe that its model is good for fast start and the code is easy to understand. The simplicity leads to less errors. Also it makes easy to contribute to a project as a review process is very clean.
• Docker is a heart of an isolation in our platform. We rely on security features (It’s not 100% safe!), metrics, ecosystem it provides. The cool thing Docker is supported by many platforms. Also Docker works a lot on a unikernel approach for container based applications, which opens a huge field for security and portability improvements.
• whisper as a discovery protocol
• Until the epoch of IPv6 begins we should bring a way to get through NAT. The solution depends on a concrete transport layer. For example, different approaches should be used for UDP (e.g. STUN) and TCP (naive userspace proxy). Each approach has its own overhead and the best fit solution depends on a task.
• gRPC is an API protocol between components. It’s very easy to extend, supports traffic compression, flexible auth model, supported by many language. It’s becoming more and more popular as a technology for RPC.

Hub provides public gRPC-based API. proto files can be found in proto dir.

Miner is expected to discover a Hub using Whisper. Later the miner connects to the hub via TCP. Right now a Miner must have a public IP address. Hub sends orders to the miner via gRPC on top of the connection. Hub pings the miner from time to time.

💚 Thanks for the Beautiful article from Bibin ✍️ | Orginal Blog/Post

The Kubernetes Learning Roadmap is constantly updated with new content, so you can be sure that you’re getting the latest and most up-to-date information available.

• Kubernetes Learning Roadmap
• Kubernetes Learning Prerequisites
• Learn Kubernetes Architecture
• $1000+ Free Cloud Credits to Launch Clusters
• The Best Resources to Learn Kubernetes Online
• Learn Kubernetes Cluster Setup & Administration
• Understand KubeConfig File
• Understand Kubernetes Objects And Resources
• Learn About Pod & Associated Resources
• Learn About Pod Dependent Objects
• Deploy End to End Application on Kubernetes
• Learn About Securing Kubernetes Cluster
• Learn About Kubernetes Operator Pattern
• Learn Important Kubernetes Configurations
• Learn Kubernetes Production Best Practices
• Real-World Kubernetes Case Studies
• Kubernetes Failures/Learnings
• Kubernetes Deployment Tools (GitOps Based)

1. Advanced Kubernetes Networking
   • Service Mesh Overview
   • Network Policies Deep Dive
   • Ingress Controllers Comparison
2. Kubernetes Observability and Monitoring
   • Monitoring Setup
   • Distributed Tracing
   • Log Aggregation
3. Advanced Cluster Management and Maintenance
   • Automated Scaling
   • Backup and Disaster Recovery
   • Cluster Upgrades
4. Security Best Practices
   • Zero-Trust Networking
   • Securing Workloads with Pod Security Policies (PSP)
   • Image Security
   • Secrets Management
5. Application Deployment Strategies
   • Advanced GitOps
   • Blue-Green Deployments
   • Canary Releases
6. Troubleshooting Kubernetes Clusters
   • Common Issues and Solutions
   • Kubernetes Debugging Tools
   • CrashLoopBackOff and OOMKill Handling
7. Additional Resources
   • Certification Study Guides
   • Community and News Sources

Learning Kubernetes can seem overwhelming. It’s a complex container orchestration system, that has a steep learning curve. But with the right roadmap and understanding of the foundational concepts, it’s something that any developer or ops person can learn.

In this Kubernetes learning roadmap, I have added prerequisites and complete Kubernetes learning path covering basic to advanced Kubernetes concepts.

Before jumping into learning kubernetes, you need to have a fair amount of knowledge of some of the underlying technologies and concepts.

1. Distributed system: Learn about distributed system basics & their use cases in modern IT infrastructure. CAP theorem is good to have knowledge.

2. Authentication & Authorization: A very basic concept in IT. However, engineers starting their careers tend to get confused. So please get a good understanding of learning from analogies. You will quite often see these terms in Kubernetes.

3. Key Value Store: It is a type of NoSQL Database. Understand just enough basics and their use cases.

4. API: Kubernetes is an API-driven system. So you need to have an understanding of RESTFUL APIs. Also, try to understand gRPC API. It’s good to have knowledge.

5. YAML: YAML stands for YAML Ain’t Markup Language. It is a data serialization language that can be used for data storage and configuration files. It’s very easy to learn and from a Kubernetes standpoint, we will use it for configuration files. So understanding YAML syntax is very important.

6. Container: Container is the basic building block of kubernetes.The primary work of Kubernetes is to orchestrate containers. You need to learn all the container basics and have hands-on experience working on container tools like Docker or Podman. I would also suggest reading about Open container initiative and Container Runtime Interface (CRI)

7. Service Discovery: It is one of the key areas of Kubernetes. You need to have basic knowledge of client-side and server-side service discovery. To put it simply, in client-side service discovery, the request goes to a service registry to get the endpoints available for backend services. In server-side service discovery, the request goes to a load balancer and the load balancer uses the service registry to get the ending of backend services.

8. Networking Basis

   • CIDR Notation & Type of IP Addresses
   • L3, L4 & L7 Layers (OSI Layers)
   • SSL/TLS: One way & Mutual TLS
   • Proxy
   • DNS
   • IPTables
   • IPVS
   • Software Defined Networking (SDN)
   • Virtual Interfaces
   • Overlay networking

Understanding Kubernetes architecture is not an easy task. The system has many moving parts that need to be understood in order for you to get a grip on what’s happening beneath the surface. While learning architecture, you will come across the concepts we discuss in the prerequisites.

As Kubernetes is a complex system, trying to understand the core architecture could be a little overwhelming for DevOps Engineers. As you get more hands-on experience, you would be able to understand the core architecture better.

Here is my suggestion. Learn the high-level architecture and key components involved in Kubernetes. If you are not able to grasp the concept, either you can spend time and do more research on a specific topic or you can learn the concept while doing hands-on. It’s your choice.

Check out the Kubernetes Architecture guide to learn about all the Kubernetes components in detail.

Overall you need to learn the following:

1. Control plane components: Understand the role of each component like API server, etcd, Scheduler, and Controller manager.

2. Worker node components: Learn about Kube Proxy, Kubelet, Container Runtime

3. Addon Components: CoreDNS, Network plugins (Calico, weave, etc), Metric Server

4. Cluster high availability: Most organizations use managed Kubernetes services (GKE, EKS, AKS, etc). So the cloud provider takes care of the cluster’s control plane’s high availability. However, it is very important to learn the high availability concepts in scaling the cluster in multi zones and regions. It will help you in real-time projects and devops interviews.

5. Network Design: While it is easy to set up a cluster in an open network without restrictions, it is not that easy in a corporate network. As a DevOps engineer, you should understand the Kubernetes network design and requirements so that you can collaborate with the network team better. For example, When I was working with kubernetes setup on Google cloud, we used a CIDR pod range that was not routable in the corporate network. As a workaround, we had to deploy IP masquerading for the pod network.

Deploying big clusters on the cloud could be expensive. So make use of the following cloud credits and learn to launch clusters as if you would on a real-time project. All platforms offer managed k8s services.

1. GKE (Google Cloud – $300 free credits)
2. EKS (AWS – $300 free POC credits)
3. DO Kubernetes (Digital Ocean – $200 free credits)
4. Linode Kubernetes Engine (Linode Cloud – $100 Free credits)
5. Vultr Kubernetes Engine (Vultr Cloud – $250 Free Credits)

Use one account at a time. Once the credits are expired. move to the next account. You need to keep a watch on your credits as well as expiry. Or else you could get charged. Also, check the terms and instance usage limits if any.

Also, setting up servers on this platform is very easy and every cloud provider had extensive documentation to get started.

Here are some of the best online resources to learn Kubernetes practically:

The official Kubernetes website offers browser-based, hands-on tutorials powered by Katacoda scenarios. It covers:

• Kubernetes Basics
• Configurations
• Stateless & Stateful Application Deployment
• Services & Networking
• Security & Access Control

🔹 You can also explore the official Kubernetes tasks for hands-on experience with real-world Kubernetes implementations. This will also help in preparing for Kubernetes certifications.

The DevOpsCube Kubernetes Tutorials provide 35+ hands-on guides covering:

• Kubernetes Architecture
• Cluster Setup & Deployments
• Best Practices
• Package & Secret Management
• Monitoring & Logging

For a fully interactive browser-based learning experience, KillerCoda offers scenario-based Kubernetes playgrounds, where you can practice commands and learn in real-time.

Kubernetes Cluster Setup

As DevOps engineers, it is very important to learn every component and cluster configuration. While there are many options to deploy a Kubernetes cluster, It is always better to learn to deploy multi-node clusters from scratch.

With multi-node clusters, you can learn about all the concepts like Cluster security, High Availability, Scaling, Networking, etc.

It gives you the feeling of working on a real-world project. It will also help you in interviews and you can be confident about production-level cluster configurations.

Following are my cluster setup suggestions.

1. Kubernetes the Hard Way: I would suggest you start with Kubernetes the hard way set up. It helps you understand all the configurations involved in bootstrapping a kubernetes cluster. If you want to work on production clusters, this lab will help you a lot. The setup is based on google cloud. You can use the $300 free credits to complete the lab.

2. Kubeadm Cluster Setup: Learning kubeadm cluster setup helps you in Kubernetes certification preparation. Also, it helps you automate Kubernetes cluster setup with best practices.

3. Minikube: If you want to have a minimal development cluster setup, minikube is the best option.

4. Kind: Kind is another local development Kubernetes cluster setup.

5. Vagrant Automated Kubernetes: If you prefer to have a multi-VM-based local Kubernetes cluster setup, you can try the automated vagrant setup that uses Kubeadm to bootstrap the cluster.

Learn About Cluster Configurations

Once you have a working cluster, you should learn about the key cluster configurations. This knowledge will be particularly helpful when working in a self-hosted Kubernetes setup.

Even if you use a managed Kubernetes cluster for your project, there may be certain cluster configurations that you need to modify.

For example, if you set up a cluster in a hybrid network, you may need to configure it with an on-premises private DNS server for private DNS resolution. This can be done via CoreDNS configuration.

Also, having a solid understanding of cluster configurations will help you with Kubernetes certifications (CKA & CKS) where you need to troubleshoot cluster misconfiguration and issues.

Kubeconfig file is a YAML file that contains all the cluster information and credentials to connect to the cluster.

As a Devops Engineer, You should learn to connect to kubernetes clusters in different ways using the Kubeconfig file. Because you will be responsible for setting up cluster authentication for CI/CD systems, providing cluster access to developers, etc.

So spend some time, understanding the Kubeconfig file structure and associated parameters.

You will quite often come across the names “Kubernetes Object” and “Kubernetes Resource“

First, you need to Understand the difference between an object and a resource in kubernetes.

To put it simply, anything a user creates and persists in Kubernetes is an object. For example, a namespace, pod, Deployment configmap, Secret, etc.

Before creating an object, you represent it in a YAML or JSON format. It is called an Object Specification (Spec). You declare the desired state of the object on the Object Spec. Once the object is created, you can retrieve its details from the Kubernetes API using Kubectl or client libraries.

As we discussed earlier in the prerequisite section, everything in Kubernetes is an API. To create different object types, there are API endpoints provided by the Kubernetes API server. Those object-specific api-endpoints are called resources. For example, an endpoint to create a pod is called a pod resource.

So when you try to create a Kubernetes Object using Kubectl, it converts the YAML spec to JSON format and sends it to the Pod resource (Pod API endpoint).

Once you have an understanding of Kubernetes Objects and resources, you can start with a native Kubernetes object called Pod. A pod is a basic building block of Kubernetes.

You should learn all the Pod concepts and their associated objects like Service, Ingress, Persistent Volume, Configmap, and Secret. Once you know everything about a pod, it is very easy to learn other pod-dependent objects like deployments, Daemonset, etc.

First, learn about the Pod Resource Definition (YAML). A typical Pod YAML contains the following high-level constructs.

• Kind
• Metadata
• Annotations
• Labels
• Selectors

Once you have a basic understanding of the above, move on to hands-on learning. These concepts will make more sense when you do hands-on.

Following are the hands-on tasks to learn about Pod and its associated objects.

1. Deploy a pod
2. Deploy pod on the specific worker node
3. Add service to pod
4. Expose the pod Service using Nodeport
5. Expose the Pod Service using Ingress
6. Setup Pod resources & limits
7. Setup Pod with startup, liveness, and readiness probes.
8. Add Persistent Volume to the pod.
9. Attach configmap to pod
10. Add Secret to pod
11. multi-container pods (sidecar container pattern)
12. Init containers
13. Ephemeral containers
14. Static Pods
15. Learn to troubleshoot Pods

Few advanced pod scheduling concepts.

1. Pod Preemption & Priority
2. Pod Disruption Budget
3. Pod Placement Using a Node Selector
4. Pod Affinity and Anti-affinity
5. Container Life Cycle Hooks

Now that you have a better understanding of Pod and independent kubernetes resources, you can start learning about objects that are dependent on the Pod object. While learning this, you will come across concepts like HPA (Horizontal Pod Autoscaling) and VPA (Verification Pod Autoscaling)

1. Replicaset
2. Deployment
3. Daemonsets
4. Statefulset
5. Jobs & Cronjobs

Once you understand the basics of these objects, you can try deploying an end-to-end microservices application on Kubernetes. Start with simple use cases and gradually increase complexity.

I would suggest you get a domain name and try setting up a microservice application from scratch and host it on your domain.

You don’t need to develop an application for this. Choose any open-source microservice-based application and deploy it. My suggestion is to choose the open-source pet clinic microservice application based on spring boot.

Following are the high-level tasks.

1. Build Docker images for all the services. Ensure you optimize the Dockerfile to reduce the Docker Image size.
2. Create manifests for all the services. (Deployment, Statefulset, Services, Configmaps, Secrets, etc)
3. Expose the front end with service type ClusterIp
4. Deploy Nginx Ingress controller and expose it with service type Loadbalancer
5. Map the load balancer IP to the domain name.
6. Create an ingress object with a DNS name with the backend as a front-end service name.
7. Validate the application.

Security is a key aspect of Kubernetes. There are many ways to implement security best practices in Kubernetes starting from building a secure container image.

Following the native ways of implementing security in kubernetes.

1. Service account
2. Pod Security Context
3. Seccomp & AppArmor
4. Role Based Access Control (RBAC)
5. Attribute-based access control (ABAC)
6. Network Policies

The following are the open-source tools you need to look at.

1. Open Policy Agent
2. Kyverno
3. Kube-bench
4. Kube-hunter
5. Falco

Kubernetes Operators is an advanced concept.

To understand operators, first, you need to learn the following Kubernetes concepts.

1. Custom resource definitions
2. Admission controllers
3. Validating & Mutating Webhooks

To get started with operators, you can try setting the following operators on Kubernetes.

1. Prometheus Operator
2. MySQL Operator

If you are a Go developer or you want to learn to extend/customize kubernetes, I would suggest you create your own operator using Golang.

While learning kubernetes, you might use a cluster in open network connectivity. So most of the tasks get executed without any issues. However, it is not the case with clusters set up on corporate networks.

So following are the some of the custom cluster configurations you should be aware of.

1. Custom DNS server
2. Custom image registry
3. Shipping logs to external logging systems
4. Kubernetes OpenID Connect
5. Segregating & securing Nodes for PCI & PII Workloads

Following are the resources that might help and add value to the Kubernetes learning process in terms of best practices.

1. 12 Factor Apps: It is a methodology that talks about how to code, deploy and maintain modern microservices-based applications. Since Kubernetes is a cloud-native microservices platform, it is a must-know concept for DevOps engineers. So when you work on a real-time kubernetes project, you can implement these 12-factor principles.

2. Kubernetes Failure Stories: Kubernetes failure stories is a website that has a list of articles that talk about failures in Kubernetes implementation. If you read those stories, you can avoid those mistakes in your kubernetes implementation.

3. Case Studies From Organizations: Spend time on use cases published by organizations on Kubernetes usage and scaling. You can learn a lot from them. Following are some of the case studies that are worth reading.

   • Scheduling 300,000 Kubernetes Pods in Production Daily
   • Scaling Kubernetes to 7,500 Nodes

When I spoke to the DevOps community, I found that a common issue was the lack of real-world experience with Kubernetes. If you don’t have an active Kubernetes project in your organization, you can refer to case studies and learning materials published by organizations that use Kubernetes. This will also help you in Kubernetes interviews.

Here are some good real-world Kubernetes case studies that can enhance your Kubernetes knowledge:

1. List of Kubernetes User Case Studies (Official Case Studies)
2. How OpenAI Scaled Kubernetes to 7,500 Nodes (Blog)
3. Testing 500 Pods Per Node (Blog)
4. Dynamic Kubernetes Cluster Scaling at Airbnb (Blog)
5. Scaling 100 to 10,000 pods on Amazon EKS (Blog)

• Learn From Kubernetes Failure Stories ^{List of Blogs}
• Reddit: The Pi-Day Outage^Blog
• How a Production Outage Was Caused Using Kubernetes Pod Priorities^Blog

GitOps is a technical practice that uses Git as a single source of truth for declarative infrastructure and application code.

• Guide to GitOps^{Official Doc}

Some popular GitOps-based tools for deploying applications to Kubernetes clusters are:

• Argo CD^{Official Doc}
• Argo Rollouts^{Official Doc}
• FluxCD^{Official Doc}
• JenkinsX^{Official Doc}

• Description: Service meshes help manage microservices networking by abstracting complex traffic management (routing, load balancing, retries, etc.).
• Popular Tools: Istio, Linkerd, and Consul.
• Use Cases: Improved resilience, observability, security, and traffic control.

• Description: Network policies allow admins to define allowed connections between pods and namespaces, enhancing security.
• Example: Create policies to block or allow traffic within namespaces, useful for internal and external isolation.

• Overview: Explore NGINX Ingress, Traefik, and HAProxy, discussing pros and cons and optimal use cases.
• Setup and Examples: Walkthrough on setting up each Ingress Controller with example configurations for HTTP and HTTPS routing.

• Description: Setting up Prometheus and Grafana for comprehensive monitoring and visualization.
• Key Metrics: Pod CPU/memory usage, node health, and custom metrics.
• Setup Guide: Installation, configuration, and Grafana dashboard examples for Kubernetes clusters.

• Overview: Explanation of distributed tracing and its importance in monitoring microservices.
• Setup: Guide to integrating Jaeger or OpenTelemetry with a sample application.
• Visualization: View and analyze request traces across services to identify bottlenecks.

• Introduction: Importance of centralized log management.
• Stack Setup: Setting up an EFK (Elasticsearch, Fluentd, Kibana) stack, with tips on log storage and retention.
• Best Practices: Log rotation, alerting, and monitoring logs for Kubernetes events.

• Overview: Types of scaling – Cluster Autoscaler, Horizontal Pod Autoscaler (HPA), and Vertical Pod Autoscaler (VPA).
• Setup Guide: How to configure autoscalers, with scenarios and examples.

• Why It Matters: Explanation of the importance of backups, especially for etcd (Kubernetes’ key-value store).
• Guide: Steps for backing up etcd and restoring it, with disaster recovery plan best practices.

• Description: Overview of the upgrade process and planning.
• Procedure: Step-by-step instructions for safely upgrading Kubernetes, managing node pools, and testing upgrades.

• Description: Introduction to Zero-Trust principles in Kubernetes.
• Implementation: Use network policies and mutual TLS (mTLS) to enforce zero-trust.

• Overview: How PSPs enforce security standards on containers (e.g., limiting root access, requiring certain security contexts).
• Examples: Sample PSPs with detailed explanations for different security levels.

• Importance: Why image security is critical.
• Tools and Setup: Integration of Trivy or Clair to automate scanning and detect vulnerabilities.
• Example Workflow: Setting up image scanning in a CI/CD pipeline.

• Best Practices: Using Kubernetes secrets for sensitive data and avoiding hard-coded values.
• Vault Integration: Step-by-step guide to integrating HashiCorp Vault for secrets management.

• Overview: Advanced GitOps concepts using tools like ArgoCD or Flux for continuous deployment.
• Examples: Real-world examples of GitOps with features like rollback, progressive delivery, and A/B testing.

• What It Is: Introduction to Blue-Green deployments to reduce downtime.
• Steps: Walkthrough on creating a Blue-Green deployment in Kubernetes using Services and Ingress.

• Definition: Canary releases gradually introduce updates to a small subset of users.
• Setup: Using Argo Rollouts to implement canary releases, with sample configurations.

• Overview: Addressing common issues like failing pods, crashed nodes, and failed deployments.
• Solutions: Detailed steps for resolving each issue, including example scenarios and kubectl commands.

• Tools Overview: Tools like kubectl-debug, K9s, and kube-ops-view for monitoring and troubleshooting.
• Usage: Example scenarios and tool usage for real-time issue identification.

• Description: Explanation of common pod errors, including CrashLoopBackOff and Out of Memory (OOM) issues.
• Resolution Steps: How to identify, troubleshoot, and resolve these issues.

• Exams Covered: CKA (Certified Kubernetes Administrator), CKAD (Certified Kubernetes Application Developer), and CKS (Certified Kubernetes Security Specialist).
• Resources: Links to official documentation, practice labs, and study guides.

• News and Blogs: Resources to stay updated with Kubernetes trends, like CNCF blog, Kubernetes Podcast, and KubeWeekly.
• Community Forums: Links to Kubernetes Slack channels, Stack Overflow, and other communities for support.

If you find this repository helpful and plan to use it for learning, please give it a star. Your support is appreciated!

This project is crafted by Harshhaa 💡.
I’d love to hear your feedback! Feel free to share your thoughts.

📧 Connect with me:

• GitHub: @NotHarshhaa
• Blog: ProDevOpsGuy
• Telegram Community: Join Here
• LinkedIn: Harshhaa Vardhan Reddy

DeRar is a simple Java program to brute force the keyword of a RAR file.

If there’s any problem regarding the program, please post an issue on the program’s GitHub page.
If you have ideas to improve the code, make sure to post a pull request.

The DeRar project and its modifications are not affiliated with or endorsed by WinRar or RarLab. The program is an independent work and is not officially supported or endorsed by WinRar or RarLab. Use of the program is at your own risk, and the creators of the program cannot be held responsible for any damages or losses that may result from its use.
Also ask the owner of the .rar archive permission before using this tool.

• The user can select several charsets to generate the combinations with, such as lower case, upper case, accented letters, special characters or digits.
• The user can specify the number of threads to run.
• The progress of each thread gets displayed in a window thanks to a progress bar.

• Optimize the code.
• Improve the GUI.
• Translate code, comments and prompts in english.
• Make the user choose between a dictionary or a brute force attack.
• Add more charsets for the user to choose from.

1. Create¹ a folder and put derar.java and utils.java inside it.
2. Place the .rar archive in the same folder.
3. Open the Windows command prompt ² and type the following commands:

• javac -encoding UTF-8 derar.java -> to compile the program
• java derar -> to run the program

The program generates every combination of words up to the user preferred length, then it tries every single one by running a cmd command.

The program asks the user to input the length of the word that will get generated with the combination algorithm. This means that the program will combine the selected characters and create words that go from the length of 1 character to the inputted length.

The user will then be asked to write the name of the file (not including the .rar extension, it is automatically concatenated to the filename string).

The last thing that will be asked to input is the number of threads the user wants to run.

The program will print a recap of the informations and the various user inputs and will prompt several requests for the press of the ENTER key, so the user can check the informations with calm.

After the recap, the open windows will get minimized to show only the desktop where a JFrame for every thread will show the progress in the checking of the combinations.

IMPORTANT: Some threads may work faster than others due to several factors such as how the processor handles them.

If the windows showing the progress of the keyword check close without the progress bars reaching 100% it means the archive got extracted in the folder it got placed in the beginning.

GitHub

Pre-compiled aria2 and AriaNg-Native with QoL modifications for Windows and Linux.

If this project helps you, a star would be greatly appreciated – it lets me know my work is useful 🙂

Make sure you understand the changes (section below) before using any release from this repo.

Please file an issue if you encounter any stability issues, particularly regarding memory leaks. Feedbacks are also much appreciated.

For updates, you can ‘Star’ this repo to see updates in your GitHub feeds, or ‘Watch’ this repo and subscribe to releases to get notified (uncheck others to avoid unwanted pings).

These softwares are mostly stable and complete, and you don’t have to update if it doesn’t deliver a feature you need.

See Releases for all previous binaries. Check out Actions for workflows to produce these binaries.

1. 0001 Configuration max-connection-per-server
   • Patch: Upper limit is removed.
   • Original behaviour: Upper limit is 16.
2. 0002 Configuration min-split-size
   • Patch: Default value is set to 4M (lower limit = 1K).
   • Original behaviour: Default value is 20M (lower limit = 1M).
3. 0003 Download at best effort
   • Patch: When ‘speed drops below lowest-speed-limit‘ or encounter ‘connection closed’, default behaviour is set to restart.
   • Original behaviour: Default behaviour is abrot.
4. 0004 Add option to retry on HTTP 4xx.
   • Patch: New options to automatically retry if http-4xx error is encountered.
     • --retry-on-400[=true|false]
     • --retry-on-403[=true|false]
     • --retry-on-406[=true|false]
     • --retry-on-unknown[=true|false]
5. 0005 New option --http-want-digest to NOT send Want-Digest HTTP header. Deprecated: aria2 has --no-want-digest-header as of 1.37.0.
6. 0006 Download to current path
   • Patch: Default output path is set to the current working path.
   • Original behaviour: Default path is $HOME (i.e. user home dir).
7. 0007 Add support for raw deflate stream.

1. 0001 Configuration max-connection-per-server
   • Patch: Value validation (upper limit) on the GUI is removed.
   • Original behaviour: Upper limit is 16.
2. 0002 Configuration min-split-size
   • Patch: Default value is set to 4M.
   • Original behaviour: Default value is 20M.
3. 0003 Configuration split
   • Patch: Default value is set to 16.
   • Original behaviour: Default value is 5.

ESP8266-based switch for openHAB.

The motivation is to build a small physical Wi-Fi enabled switch that controls lights via openHAB. It should require only a power cable and send the commands via Wi-Fi and MQTT to the openHAB server which then controls the lights.

Besides the openHAB server and some lights (this guide uses Philips Hue lights but others work as well), the following components are used:

• Adafruit Feather HUZZAH with ESP8266
• Adafruit FeatherWing OLED – 128×32 OLED Add-on

The OLED display is used to show network information and confirmation of the commands. The switch setup would probably also work with other ESP8266 boards but Adafruit’s Feather board is nice and easy to use. The buttons on the OLED board are used as the switch buttons but it’s also possible to use externally connected buttons/switches.

Flash the Arduino sketch esp8266-openhab-switch.ino to the board. Don’t forget to adjust the Wi-Fi and MQTT settings at the beginning of the sketch. The sketch requires that the ESP8266 drivers are installed and the Adafruit libraries for the Feather board and the OLED board are loaded in the Arduino IDE.

Detailed instructions on how to use Adafruit’s ESP8266 Feather board with the Arduino IDE can be found here: https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/using-arduino-ide

On the openHAB2 server, first install the MQTT server and the openHAB MQTT binding. When using openHAB2 on a Raspberry Pi with Raspbian, the MQTT server can be installed with the following commands:

wget http://repo.mosquitto.org/debian/mosquitto-repo.gpg.key
sudo apt-key add mosquitto-repo.gpg.key
cd /etc/apt/sources.list.d/
sudo wget http://repo.mosquitto.org/debian/mosquitto-wheezy.list
sudo apt-get install mosquitto

After that the MQTT binding can be installed via the Paper UI. There’s also a good beginner’s guide on MakeUsOf that explains how to setup and test the MQTT server and binding. After installation, the MQTT binding has to be configured as shown in services/mqtt.cfg.

In addition to the Hue light kitchen_ceiling_light_dimmer, two items are defined in the item file items/all.items: A dimmer that represents the ESP8266 board and a string to send a message to the ESP8266 OLED display, both connected to MQTT.

The rule file rules/esp8266_switch.rules defines the dimmer behavior. The ESP8266 board sends values 100, 50, and 0 with the buttons A, B, and C via MQTT. The rule Kitchen Switch sets the Hue light state to the value that the board sent. The rule Kitchen Switch Display sends a string with the Hue light state to the board so it can be displayed. What’s cool here is that this string gets sent whenever the light state is changed, even through another UI (e.g. the Android app).

Reseved Slots is a CS2 plugin that is used to reserve slots for VIP players or Admins.
Designed for CounterStrikeSharp framework

1. Download the lastest release https://github.com/NockyCZ/CS2-ReservedSlots/releases/latest
   • ReservedSlots.zip file is a version that does not support Discord Utilities
   • ReservedSlots_DU_Support.zip file is a version that supports Discord Utilities (You can combine flags and discord roles)
2. Unzip into your servers csgo/addons/counterstrikesharp/plugins/ dir
3. Restart the server

• CS2 Discord Utilities (Only if you want to use a version thats supports Discord Utilities)

configs/plugins/ReservedSlots/ReservedSlots.json

Geekx is a Free and Open Source Four Column portfolio template for Bootstrap with responsive and high quality UI created by Orbit Themes.

View Demo | Download ZIP

View Live Preview

• Responsive Design.
• Developed With Bootstrap 4.
• SEO Semantic Code.
• Simple and Easy To Use.
• HTML5 ready. Use the new elements with confidence.
• Designed with progressive enhancement in mind.

To begin using this template, choose one of the following options to get started:

• Download the latest release on Orbit Themes
• Install via npm: npm i geekx
• Clone the repository: git clone https://github.com/orbitthemes/geekx.git

    # clone the repository
    $ git clone https://github.com/orbitthemes/geekx.git

    # go into the directory
    $ cd geekx

    # install all dependencies
    $ npm install

    #For Development Options
    $ gulp dev

• Fork, Clone, or Download on GitHub

After downloading, simply edit the HTML and CSS files included with the template in your favorite text editor to make changes. These are the only files you need to worry about, you can ignore everything else! To preview the changes you make to the code, you can open the index.html file in your web browser.

After installation, run npm install and then run gulp dev which will open up a preview of the template in your default browser, watch for changes to core template files, and live reload the browser when changes are saved. You can view the gulpfile.js to see which tasks are included with the dev environment.

• gulp the default task that builds everything.
• gulp dev browserSync opens the project in your default browser and live reloads when changes are made.
• gulp css:compile compiles the SCSS into CSS file.
• gulp css:minify minifies the compiled CSS file.
• gulp css compiles SCSS files into CSS and minify the css.
• gulp js Combines all js scripts to one file named main.js, Minify the file, and save it as main.min.js.
• gulp export copies dependencies from node_modules to the dist directory.
• gulp clean Removes all the directories inside dist, minified js files and all compiled css files.

Have a bug or an issue with this template? Open a new issue on GitHub or leave a comment on the template overview page at Orbit Themes.

You can hire Orbit Themes to create a custom build of any template, or create something from scratch using Bootstrap. For more information, visit the Contact Page.

• Album Plus – Album Plus is a Simple Photography and Magazine template for Bootstrap 4.
• Blog – Blog Is The Beautiful Blogger Template For Bootstrap 4.
• My Shop – My Shop is a Simple E-Commerce template for Bootstrap 4.
• Carousel Plus – Clean and Responsive Bootstrap 4 slideshow Template.
• Checkout Plus – Simple, Clean and Stylish Bootstrap 4 Checkout Page Template.
• Cover Plus – Cover Plus Is The Beautiful One Page Template for Bootstrap 4.
• Dashboard – Free and Responsive admin dashboard template for bootstrap 4.
• Healthy – Clean Responsive Fitness Landing Page For Bootstrap 4.
• Kreative – Kreative Business Landing Page Template.
• Pricing Plus – Clean and Responsive Pricing Page Template With High Quality UI.

To contribute, please ensure that you have stable Node.js and npm installed. Test if Gulp CLI is installed by running gulp --version. If the command isn’t found, run npm install -g gulp. For more information about installing Gulp, see the Gulp’s Getting Started!.

To have all gulp dependencies run npm install

If gulp is installed, follow the steps below.

• Fork and clone the repository.
• Run gulp dev, this will open Template on your default browser.
• Now you can code, code and code!
• Submit a pull request.

Orbit Themes is an open source library of free Bootstrap templates and themes. All of the free templates and themes on Orbit Themes are released under the MIT license, which means you can use them for any purpose, even for commercial projects.

• Web: https://orbitthemes.com
• Twitter: https://twitter.com/orbitthemes
• Facebook: https://www.facebook.com/orbitthemes/
• Google Plus: https://plus.google.com/+orbitthemes
• Github: https://github.com/orbitthemes
• Behance: https://www.behance.net/orbitthemes
• Dribble: https://dribbble.com/orbitthemes
• Pinterest: https://www.pinterest.com/orbitThemes/
• Reddit: https://www.reddit.com/user/orbitthemes
• Instagram: https://www.instagram.com/orbitthemes/
• LinkedIn: https://www.linkedin.com/company/orbit-themes/

Orbit Themes was created by and is maintained by Sandeep Prasad Bhatt .

• http://sandeepbhatt.com.np
• https://twitter.com/_MeSandy
• https://github.com/sandy100

Orbit Theme Templates and Themes are based on the Bootstrap framework created by Mark Otto and Jacob Thorton.

• node.js
• gulp
• jQuery
• Bootstrap
• SASS
• Pexels

Copyright 2018 Orbit Themes. Code released under the MIT.

The ICT HelpDesk Application is a web-based solution designed to facilitate the management of technical issues within an organization. It provides a platform for clients to report issues and for HelpDesk officers to manage, assign, and resolve these issues effectively.

• User Authentication: Secure login and registration for clients and HelpDesk staff.
• Role-Based Access Control: Different functionalities for clients, General HelpDesk Officers, and HelpDesk Officers.
• Issue Reporting: Clients can report technical issues they encounter.
• Issue Assignment: General HelpDesk Officers can assign reported issues to specific HelpDesk Officers.
• Issue Management: HelpDesk Officers can view, manage, and resolve assigned issues.
• Notifications: Alerts for issue assignments and updates.

• Backend: Laravel
• Frontend: Blade, Tailwind CSS
• Authentication: Laravel Breeze

Ensure you have the following installed:

• PHP >= 8.1
• Composer
• Node.js and npm
• MySQL or other compatible database

1. Clone the Repository:

   git clone https://github.com/yourusername/ict-helpdesk.git
   cd ict-helpdesk

2. Install Dependencies:

   composer install
   npm install

3. Copy .env.example to .env:

   cp .env.example .env

4. Generate Application Key:

   php artisan key:generate

5. Configure Database:

   Update .env with your database credentials:

   DB_CONNECTION=mysql
   DB_HOST=127.0.0.1
   DB_PORT=3306
   DB_DATABASE=ict_helpdesk
   DB_USERNAME=root
   DB_PASSWORD=yourpassword
   

6. Run Migrations:

   php artisan migrate

   Seed the database

   php artisan migrate:fresh --seed

7. Install Tailwind CSS:

   npm run dev

8. Start the Development Server:

   php artisan serve

9. Access the Application:

   Open your browser and navigate to http://localhost:8000.

1. Register Users:

   • Client: Sign up through the registration form.
   • General HelpDesk Officer & HelpDesk Officers: Create their accounts via the registration form and update their roles in the database.

2. Reporting Issues:

   • Clients can log in and submit a new issue via the “Report Issue” form.

3. Assigning Issues:

   • General HelpDesk Officers can log in and assign pending issues to HelpDesk Officers.

4. Managing Issues:

   • HelpDesk Officers can view their assigned issues, update their status, and mark them as resolved.

• app/Models: Models such as User, Issue, and Assignment.
• app/Http/Controllers: Controllers like IssueController, AssignmentController.
• resources/views: Blade templates for the UI.
• database/migrations: Migration files for database schema.
• routes/web.php: Web routes for the application.

To deploy the application, follow standard Laravel deployment practices:

1. Server Setup: Configure a web server (e.g., Apache, Nginx) and set up the environment.
2. Database Migration: Run migrations on the production database.
3. Optimize: Run optimization commands:

   php artisan config:cache
   php artisan route:cache
   php artisan view:cache

4. Build Assets:

   npm run production

Contributions are welcome! Please fork the repository and submit a pull request.

1. Fork the repository
2. Create a new branch (git checkout -b feature-branch)
3. Commit your changes (git commit -am 'Add new feature')
4. Push to the branch (git push origin feature-branch)
5. Create a new Pull Request

This project is licensed under the MIT License. See the LICENSE file for more details.

• Laravel
• Tailwind CSS
• Laravel Breeze

For any inquiries or issues, please contact tituskiptanuitum@gmail.com.

A blueprint for getting a React web app with a C# API and a SQL database running on Azure. The blueprint includes sample application code (a ToDo web app) which can be removed and replaced with your own application code. Add your own source code and leverage the Infrastructure as Code assets (written in Bicep) to get up and running quickly.

Let’s jump in and get this up and running in Azure. When you are finished, you will have a fully functional web app deployed to the cloud. In later steps, you’ll see how to setup a pipeline and monitor the application.

^{Screenshot of the deployed ToDo app}

This template will create infrastructure and deploy code to Azure. If you don’t have an Azure Subscription, you can sign up for a free account here. Make sure you have contributor role to the Azure subscription.

The following prerequisites are required to use this application. Please ensure that you have them all installed locally.

• Azure Developer CLI
• .NET SDK 8.0 – for the API backend
• Node.js with npm (18.17.1+) – for the Web frontend

To learn how to get started with any template, follow the steps in this quickstart with this template (Azure-Samples/todo-csharp-sql).

This quickstart will show you how to authenticate on Azure, initialize using a template, provision infrastructure and deploy code on Azure via the following commands:

# Log in to azd. Only required once per-install.
azd auth login

# First-time project setup. Initialize a project in the current directory, using this template.
azd init --template Azure-Samples/todo-csharp-sql

# Provision and deploy to Azure
azd up

This application utilizes the following Azure resources:

• Azure App Services to host the Web frontend and API backend
• Azure SQL Database for storage
• Azure Monitor for monitoring and logging
• Azure Key Vault for securing secrets

Here’s a high level architecture diagram that illustrates these components. Notice that these are all contained within a single resource group, that will be created for you when you create the resources.

This template provisions resources to an Azure subscription that you will select upon provisioning them. Refer to the Pricing calculator for Microsoft Azure to estimate the cost you might incur when this template is running on Azure and, if needed, update the included Azure resource definitions found in infra/main.bicep to suit your needs.

This template is structured to follow the Azure Developer CLI. You can learn more about azd architecture in the official documentation.

At this point, you have a complete application deployed on Azure. But there is much more that the Azure Developer CLI can do. These next steps will introduce you to additional commands that will make creating applications on Azure much easier. Using the Azure Developer CLI, you can setup your pipelines, monitor your application, test and debug locally.

Note: Needs to manually install setup-azd extension for Azure DevOps (azdo).

• azd pipeline config – to configure a CI/CD pipeline (using GitHub Actions or Azure DevOps) to deploy your application whenever code is pushed to the main branch.

• azd monitor – to monitor the application and quickly navigate to the various Application Insights dashboards (e.g. overview, live metrics, logs)

• Run and Debug Locally – using Visual Studio Code and the Azure Developer CLI extension

• azd down – to delete all the Azure resources created with this template

• Enable optional features, like APIM – for enhanced backend API protection and observability

The Azure Developer CLI includes many other commands to help with your Azure development experience. You can view these commands at the terminal by running azd help. You can also view the full list of commands on our Azure Developer CLI command page.

This template creates a managed identity for your app inside your Azure Active Directory tenant, and it is used to authenticate your app with Azure and other services that support Azure AD authentication like Key Vault via access policies. You will see principalId referenced in the infrastructure as code files, that refers to the id of the currently logged in Azure Developer CLI user, which will be granted access policies and permissions to run the application locally. To view your managed identity in the Azure Portal, follow these steps.

The template will also create a dedicated Azure SQL user for the application and store its credentials in a KeyVault (see below). The application user’s access is restricted to the ToDo database only; a separate administrator account is set up for managing the whole Azure SQL instance.

This template uses Azure Key Vault to securely store your Azure SQL Database credentials and the connection string used by the application to interact with the database. Key Vault is a cloud service for securely storing and accessing secrets (API keys, passwords, certificates, cryptographic keys) and makes it simple to give other Azure services access to them. As you continue developing your solution, you may add as many secrets to your Key Vault as you require.

If you have any feature requests, issues, or areas for improvement, please file an issue. To keep up-to-date, ask questions, or share suggestions, join our GitHub Discussions. You may also contact us via AzDevTeam@microsoft.com.