Hashicorp Vault CLI Part 5: Vault Enterprise

Hashicorp Vault CLI Part 4: Introspection

Hashicorp Vault CLI Part 3: Plugin Management and General CRUD Operations

Hashicorp Vault: TOTP Secrets Engine

Hashicorp Vault: Transit Secrets Engine

Hashicorp Vault: Fine-Grained Access Control with Policies

Hashicorp Vault: Authentication Provider Almanac

Hashicorp Vault: Token Management via CLI and API

Hashicorp Vault: An Inquiry into the Nature of Tokens

Hashicorp Vault: Secret Management Engines

Hashicorp Vault CLI Part 2: Operation Commands

Hashicorp Vault CLI Part 1: Initialization

Hashicorp Vault: High-Level Architecture, Components, and Key Concepts

Hashicorp Vault: An Introduction to the Secrets Management Application

OpenMQTT Gateway: Messages and Commands

OpenMQTT Gateway for Infrared Signals

OpenMQTT Gateway for Bluetooth BLE Signals

OpenMQTT Gateway for Radio Frequency Signals

Home Assistant: Integrating Raspberry Pico Boards

RFID & NFC with ESP8266

Reading and Writing RFID Cards with Raspberry Pi

Remote GPS Sensor: Build & Assembly

Remote GPS Sensor: Data Transmission with NRF24L01

Remote GPS Sensor: Component Selection and GPS Coding

Home Assistant: Measuring Sound and Vibration

Home Assistant: Light Intensity Sensor APDS-9960

IOT: How to Capture all Log Files from Systems, Applications & Sensors

IOT: Debugging InfluxDB Storage Errors

IOT: Log File Collection with Fluent Bit

IOT: How to Collect ESP8266 Sensor Hardware Metrics with Home Assistant

Hardware Metrics Collection with IOT Devices

IOT Security Camera with a Raspberry Pi Zero and External USB Webcam

Home Assistant: Measuring Air Quality, Humidity and Temperature with a BME680 Sensor

Home Assistant: How to Measure Battery Voltage of ESP8266 Boards

Tasmotizer: Try to Flash a WiFi LED Light with a Custom Firmware

Tasmotizer: How to Flash a Sonoff S26R2 Power Switch with Custom Firmware

Home Assistant: Overview about Smart Light and Smart Power Protocol

Home Assistant and ESP Home: How to use MQTT Integration for Dynamic Device Configuration

IOT: Dynamic Deep Sleep Configuration for ESP8266 and ESP32 Boards

Home Assistant: How to Fix API Disconnection and False Positive Sensor Readings with ESP8266 Boards

InfluxDB: Optimize your Data with Data Retention Policies and Continuous Queries

Universal Personal Assistant with LLMs

LLM Evaluation: Which LLM to use for developing a personal assistant?

Fine-Tuning LLMs: Comparison of Collab, Kaggle and 6 other Platforms

Fine Tuning LLMs: Training with Cloud Resources

LLM GUI: Custom Python Gradio Interface

LLM Agents: Introduction to CrewAI

LLM Agents: Multi-Agent Chats with Autogen

LLM Agents: Custom Tools in Autogen

LLM Agents: Introduction to Autogen

LangChain: Building a local Chat Agent with Custom Tools and Chat History

Advanced LangChain: Memory, Tools, Agents

Retrieval Augmented Generation Frameworks: AutoGen

Retrieval Augmented Generation Frameworks: HayStack

Retrieval Augmented Generation Frameworks: LangChain

QA System Design with LLMs: Prompt Engineering

QA System Design with LLMs: Practical Instruction Fine-Tuning Gen3 and Gen4 models

Instruction Fine-Tuning: Dataset and Library Landscape

LLM Fine-Tuning: Domain Embeddings with GPT-3

LLM Fine-Tuning Workshop: Improve Question-Answering Skills

LLM Fine-Tuning Workshop: Improve Linguistic Skills

Lighthouse Service Discontinued

Fine-Tuning LLMs: Technical Overview

Question-Answer System Architectures using LLMs

Building a Question-Answer System with Machine Learning Algorithms

NLP Tasks with the Haystack LLM Library

NLP Tasks with the Gpt4All LLM Library

NLP Tasks with the LangChain LLM Library

NLP Tasks with the Transformers LLM Library

LLMs on your local Computer (Part 2)

LLMs on your local Computer (Part 1)

Large Language Models: Library Overview for Training, Fine-Tuning, Intererence and More

Large Language Models: Modern Gen4 LLM Overview (LLaMA, Pythia, PaLM2 and More)

Large Language Models: Comparing Gen2/Gen3 Models (Bloom, Gopher, OPT and More)

Large Language Models: Comparing Gen2/Gen3 Models (GPT-3, GPT-J, MT5 and More)

Large Language Models: Comparing Gen 1 Models (GPT, BERT, T5 and More)

Introduction to Large Language Models

Raspberry Pico Badger: Custom App Development for MQTT Message Display and Graph Visualization

Raspberry Pico Badger: Hardware Features and OS

ESP32 Camera: Hardware and GPIO Functions

Arduino Nano BLE 33 Sense Microcontroller: Hardware and GPIO Functions

The Tinker Board Single Board Computer: Hardware and GPIO Functions

Wikipedia Article Crawler & Clustering: Text Classification with Spacy

NLP with Spacy: Custom Text Classification Pipeline

Wikipedia Article Crawler & Clustering: Advanced Clustering and Visualization

Wikipedia Article Crawler & Clustering: KMeans

NLP Project: Text Vectorization Usage with Pandas and SciKit Learn

NLP: Text Vectorization Methods with SciKit Learn

NLP: Text Vectorization Methods from Scratch

NLP Project: Wikipedia Article Crawler & Classification - Corpus Transformation Pipeline

NLP Project: Wikipedia Article Crawler & Classification - Corpus Reader

Python NLP Library: Flair

Python NLP Library: Spacy

Python NLP Library: NLTK

Python NLP Libraries: A Comprehensive Overview

An Introduction to Natural Language Processing

Kubernetes with K3S: How I Upgraded a Production Cluster from v1.17 to v1.25

Terraform Workshop: Automated Account and S3 Bucket Creation on AWS

Terraform Workshop: Manage Hetzner Cloud Servers

Terraform Language Compendium

Terraform: Modules and Workspaces

Terraform: Advanced Commands Overview

Terraform: Standard Workflow and State Facilitation

Terraform: A gentle Introduction

Raspberry Pi Tank Kit: Assembly & Installation on Ubuntu Server 20.04

Robotic Arm: Movement Controller Software

Robotic Arm: Message Controller Software

Robotic Arm: Assembly & Software Installation

Home Assistant: Collecting Sensor Data with InfluxDB

Home Assistant: Learn how to Automize your Home

IOT: Traefik Reverse Proxy for HTTPS Connection to Docker Containers

IOT Stack on Raspberry Pi: Full Upgrade Procedure

Kubernetes with Red Hat Open Shift

Google Kubernetes Engine: Mostly Automated Installation with Terraform

Kubernetes with Amazon Elastic Kubernetes Service

Kubernetes with Kubeadm: Fully Automated Installation with Terraform

Kubernetes with Kops: Mostly Automated Installation with Terraform

Kubernetes Installation Tutorial: Kubespray

Kubernetes with Kubeadm: Cluster Installation from Scratch

Kubernetes Cluster Installation: K3S

Kubernetes with kops

Kubernetes with Kubeadm

Kubernetes with Kubespray

Kubernetes with K3S

Kubernetes from Scratch in 2022

Home Assistant: Use a Motion Sensor to Automatically Control Lights

IOT on Raspberry Pi: Install Home Assistant and a Camera Sensor for Live Video

IOT on Raspberry Pi: Automatic Sensor Management with ESPHome

IOT Sensor Project: ESP8266 with DHT11 Sensor sends Data to MQTT

Raspberry Pi: Comparing HDD Disk Read and Write Performance for external USB and SATA Drives

IOT Stack: Measuring the Heartbeat of all Devices & Computer

IOT Stack on the Raspberry Pi: Hardware Metrics Monitoring with Telegraf

IOT Stack on the Raspberry Pi

RADU: Project Conclusion

RADU: Controlling Robot Wheel and ARM Movements with a Gamepad Controller using Python

RADU: Adding a Custom Remote Controller

RADU: Control the Robot using a Joystick

RADU: Processing & Interpreting ROS Movement Messages with Python

RADU: Motor Controller Software for Arduino and Raspberry Pico

RADU: Realsense D435 Installation Troubles with ROS2

Robotic Projects: Reasons for Switching from ROS2 to ROS1

ROS: Simultaneous Mapping and Localization with RTABmap

ROS with Raspberry Pi: Investigating the Core Issue of Slow Streaming Performance

ROS with Raspberry Pi: Improving Image Streaming Performance

ROS with Raspberry Pi: Improving WIFI Upload Speed

RGB Depth Camera in Robotics: Starting with the Realsense R435 SDK

Robot Operating System: Installation & Configuration on a Raspberry Pi with Ubuntu Server

RADU: Visual Sensor Overview

RADU: From Stationary to Moving Robot

RADU: How to build a Robot with Arduino and Raspberry Pi

Robot Operating System: Requirements for Autonomous Navigation

Robot Operating System: How to Model Point Cloud Data in ROS2

Robot Operating System: Controlling a Robot with the ROS Gazebo Plugins

Robot Operating System: Expose Control Nodes for an Interactive Simulation in Gazebo

Robot Operating System: Getting Started with Simulation in ROS2

Robot Operating System: Practical Guide for Migrating from ROS1 to ROS2

Robot Operating System: How to Create a Robot Simulation Model (Part 2)

Robot Operating System: How to Create a Robot Simulation Model

Robot Operating System: How to Start the Robot Simulation Tool Rviz

Robot Operating System: Installation Instructions for Ubuntu

Robot Operating System: Introduction

Building a Custom PC in 2021

Python: Effective Serial Data Processing

Serial Connection between Raspberry Pi and Raspberry Pico

Arduino: How to select a Sensor/Hardware Library?

How to Learn C/C++ for Microcontroller Programming?

Arduino: How to Process Infrared Signals from a Remote Control

Tutorial: Serial Connection Between Raspberry Pi and Arduino

Connecting Microcontrollers: Direct Serial Connection

Arduino: Implementing a Simple Terminal Prompt

Raspberry Pi: Python Libraries for I2C, SPI, UART

GPIO Programming on the Raspberry Pi: Python Libraries

Raspberry Pi: C++ Libraries for working with I2C, SPI and UART

Arduino Microcontroller: How to Use I2C, SPI, and UART

Microcontroller Connection Protocols: W1, I2C, SPI, UART

The Raspberry Pico Microcontroller: Hardware and GPIO Functions

The Raspberry Pi Single-Board-Computer: Hardware and GPIO Functions

The Arduino Microcontroller: Hardware and GPIO Functions

Introduction to Single-Board Computers

DHT11s Temperature Sensor Library for the Raspberry Pico: Python Prototype

Raspberry Pico: The Complete SDK Overview (Native C/C++, Arduino, MicroPython, CircuitPython)

Raspberry Pico: Programming with PIO State Machines

DHT11 Temperature Sensor Library for the Raspberry Pico

Raspberry Pico and CMake: Advanced Setup

Getting started with Raspberry Pico and CMake

Shift Register Library for the Raspberry Pico: Library Implementation

Shift Register Library for the Raspberry Pico: Shift Register Essentials and Library Design

Raspberry Pico: Unit Test Framework for Your Projects

Service Breakdown in my Kubernetes Cluster: Steps, Solution, Learning

Raspberry Pico: Simple Debugging with just one Device

The Simple Startup with PlatformIO

Self-Made-Robot: Bill of Materials

Robot Systems: Software Stack Overview

Robot Systems: Hardware Overview

Self-Made-Robot: Review Robots Projects

Building a Robot from Scratch: Project Outline

ApiBlaze: Designing the Search API for Properties & Endpoints

ApiBlaze: UI for Searching API Elements

ApiBlaze: Parsing and Searching Elements in OpenApi Specs

ApiBlaze: Websocket Backend

Websockets: Blazing Fast Data Exchange

ApiBlaze: UI-Interactions for Searching APIs

ApiBlaze: Designing the API Search Bar

ApiBlaze: SPAC Framework Refactoring

OpenAPI: Documentation Tool Overview

OpenAPI: How to Design API Specifications

SPAC: Publishing Apps

SPAC: Promise-Based Actions

SPAC: Stateful Pages and Components

SPAC: Designing Pages and Components

SPAC: Web APIs for Page Transitions & Persistence

SPAC: Controller Self-Initialization & Object API

SPAC: Controller Implementation

JavaScript: Developing a Custom Framework for Single-Page-Apps

ApiBlaze: Development Phases

ApiBlaze: A new Developer Journey

Learning JavaScript: Project Recap

Ansible: Idempotent Playbooks

Ansible: Checking and Controlling Task Execution, Orchestration and Scope

Ansible: Influencing Action Execution with Conditions and Branches

Ansible: Boost Task Execution Speed

Ansible: Boost Task Execution Speed

Ansible: Working with Variables and Hostvars

Ansible: Working with Variables and Hostvars

Kubernetes: Defining a CronJob for Collecting Log Data

Kubernetes API: How Custom Service Accounts Work

Kubernetes: Building a Custom Log Exporter with NodeJS

Kubernetes: Protect Resource Consumption with Limits and Health Checks

Kubernetes: Private Docker Registry in 5 Minutes

Kubernetes: Automatic Let's Encrypt Certificates for Services

Kubernetes Made Simple with K3S

Lighthouse goes Serverless: Using OpenFaaS for Running Functions

OpenFaaS: Serverless Functions Deepdive

Lighthouse Scanner: Setup Local Kubernetes Staging Environment

Docker: Building Images for Multiple Architectures

Lighthouse Scanner: From Monolith to Microservices

Software Development Practices: Drive-By-Testing

Lighthouse Scanner: Deploying with Kubernetes

A Webserver running on Arduino Nano ESP Sensor

Lighthouse Scanner: Stateless NodeJS Microservices with Redis DB

Using Ansible for Hosting a Blog on a Cloud Server

Lighthouse Scanner: Frontend Development with PlainJS

Encrypt Status Communication Messages in Consul and Nomad

Lighthouse Scanner: Microservice Development with the Hapi Framework

Nginx Reverse Proxy with TLS Encryption

Nginx as a Reverse Proxy

Persisting Data with Nomad

Lighthouse as a Service: Scan WebPages for Performance, SEO and Best Practices

Service Discovery with Consul and Traefik

Collecting Hardware Metrics with Nomad

Application Management with Nomad

Infrastructure@Home: Towards Collecting Hardware Metrics

Infrastructure@Home: Using Ansible to Install the Service Monitoring Software Consul

Infrastructure@Home: Infrastructure Management

Infrastructure@Home: Configuration Management with Ansible

Infrastructure@Home: A new Project

React: How to Design Smooth Page Transitions and Animations

Introduction to React Router

React: How Tests will Boost your Development Speed

Structuring React Projects

React: Creating a Custom Hook for Fetching Data

React: Creating a Custom Hook for Pagination

React: Introduction to Functional Components & Hooks

React: Designing a Board Game App