663 docs tagged with "DevOps"

Authentication, Authorization, and Access Control

Access Logs

Using Access Control List (ACL) Plugin in Kong

Ad Hoc Commands, Playbooks, and Variables

Adding Entrypoint in Docker Compose

Kubernetes plugins enforcing API policies

Accelerate Digital Transformation

Advanced Operations

Advanced Topics

Advanced VPC with ALB and EC2

Advanced VPC with ALB and EC2 Simplified

Advanced VPC with Cloud Native Application

Aggregation Examples

Aggregation Operators in PromQL

Aggregations

GCP AI and ML Services

Artificial Intelligence and Machine Learning

Using AI Prompt Decorator Plugin in Kong

Using AI Prompt Plugin in Kong

Using AI Prompt Template Plugin in Kong

Using AI Proxy Plugin in Kong

CloudWatch Alarms and EventBridge

Alert Rule with Email Notification

Alertmanager Architecture

Alerting in Prometheus

Creating a VM

Fully managed 'front-door' for applications

Serverless, interactive analytics service

Fully managed and scalable IAM

Fully managed NoSQL database

Intelligent threat detection

Automated and continual vulnerability management

Real-time streaming data at a large scale

Protecting sensitive data

Fully managed, open-source message brokers

Amazon Opensearch

Relational database service

Securing your Amazon RDS Databases

Amazon Simple Storage Service (Amazon S3)

Fully managed Pub/Sub service

Distributed message queuing service

GCP Smart Analytics Services

Azure Analytics

Starter Notes on Ansible

Ansible Inventory Yaml

Ansible Notes

Ansible Quickstarts

Ansible Roles

Apache Hadoop

Apache Kafka

Apache Spark

API Management in Azure

Improving API performance using response cachine and usage quotas

Linux security module for application access control.

AWS application delivery and storage Terraform patterns

Deploying Cloud Native Applications

Layer 7 LoadBalancer for your applications

Application Insights

Application Lifecycle Management

Application Map

Application Security

Elasticsearch Archietcture

OpenStack Architecture

ArgoCD

Attach and detaching from containers

Audit Logs for Access Monitoring

APIM Authentication in Azure

Authentication and Authorization

Authentication and Encryption in Prometheus

Authentication Mechanisms

APIM Authorization by Policies

Authorization Mechanisms

Basics of AWS Compute

Auto-Instrumentation

What good automation looks like

Compliance Management with Artifact and Macie

How AWS Billing Works

Provision and manage SSL/TLS certificates

Using CLI and SDK

Infrastructure As Code by AWS

Fully managed continuous integration

Private Git repositories in AWS

AWS CodeDeploy

Fully managed continuous delivery

Basics of AWS Compute

Assess, audit, and evaluate configurations

Running containers in AWS

Different database options in AWS

Disaster Recovery Methods

Using FluxCD with Helm Charts in AWS EKS and ECR

Managed application deployment

First things you need to know

Using CLI and SDK

Create and control your cryptographic keys

AWS Logs

AWS Pricing

Build and deploy serverless applications

Centrally manage your secrets

Securing your AWS Account

Resources for the exam

Migrate petabyte-scale data to AWS

Comparing AWS Storage Options

Use cloud storage with on-prem applications

Optimize costs, performance, etc.

Active Directory in Azure

Fully managed platform as a service (PaaS)

Architecting solutions in Azure

Scalable and secure object storage in the cloud

Virtual machines in Azure

Analyze all your data in a single place

Integration with Azure over a private connection

Managed File Shares and Storage

Azure's Content Delivery Network (CDN)

Serverless compute in Azure

Identity and Access Management

Distributing traffic across backend resources

Serverless workflow integration platform

Block storage for Azure Virtual Machines

Secure yoru Azure resources with MFA.

Migrating applications to Azure

Azure Monitor

Durable queues for large-volume cloud services.

Azure Security Overview

Highly available storage in the cloud

Storage for non-relational structured data in the cloud

Private networks in Azure

Centralized protection of your web applications

Basic Auth

Using Basic Authentication in Kong

Being Cloud Native

Building a Restaurant API using Azure Function Apps

Certificate Authority

Notes for the Microsoft Azure Security Technologies (AZ-500)

Changing deprecated API versions

Cheatsheet: Kubernetes Commands

Chrome DevTools

CI/CD with Jenkins

Set up CI/CD pipelines in AWS

Cinder – Persistent Block Storage

CIS Security Benchmarks

Passing an Argument

Using Client Libraries

Overview

Public Cloud

Cloud Computing

Being Cloud Native

Software as a Service (SaaS)

Amazon CloudTrail

Amazon CloudWatch

Cluster AutoScaler in EKS

Cluster Maintenance

Defining default commands on containers

CNCF Projects

Common Log Formats

Overview

Common Transformers

Communications between networks and resources

Etsy

Components of an Azure LoadBalancer

OpenStack Components

Compress

GCP Compute Services

Dealing with Concurrency in Elasticsearch

Conditionals

Storing non-sensitive data

Alertmanager Configuration

Configuration, Errors, and References

Configurations

Configuring Traefik

Visualization using Console Templates

Consumers, Plugins, and Upstreams

Container Best Practices

Container Metrics

Container Resource Requirements

Isolating containers for enhanced security

Container Security

Containerized Kong and Other Applications

Container Management Challenges

Containers in Azure

Control Flow, Roles, and Errors

Control Structures

Copying gitconfig onto the Nodes

Cost Management in AWS

Cost Optimization in AWS

Create a Log Analytics Workspace

Create a Monitoring Dashboard

Create Application Insights

Create the Virtual Networks

Create the Virtual Machines

Creating a Basic Ansible Playbook

Creating Users

Creating Users using Ansible Roles

Creating Users with Conditionals and Variables

Creating Users with Passwords stored in Ansible Vault

CRUD Operations

Custom Kuberenetes resource types

Container Management Challenges

Dashboards

Datacenters

Data Modelling and Parent-Child Relationships in Elasticsearch

Data Processing in Azure

Ways to protect your data in AWS

Database Security

A 10,000 ft view of Microsoft Azure

Distributed Denial of Service (DDoS)

Dependencies in Docker Compose

Terraform dependencies and graph behavior

Deploy Nginx with Helm

Deploy S3 Bucket

Deploy Traefik with Docker

Deploying a LAMP Stack and Python Application

Deploying a Web Application (TBC)

Deploying Elastic Beanstalk

Deploying Elastic Beanstalk Version 1

Deploying Jenkins

Deploying LAMP Server (TBC)

OpenStack Deployment Methods

Deployment environments and models

Deployments

Dev Environment for AWS IoT Greengrass

Dev Environment for Docker and Kubernetes

Dev Environment for Docker and Kubernetes Version 2

Dev Environment for RedHat

Dev Environment in AWS Cloud

Dev Environment in Azure

In a Nutshell

Using DigitalOcean

Disable open ports

Dead-Letter Queue Plugin

Using Let's Encrypt DNS Challenge

Docker application deployment

Docker Architecture

Docker Cheatsheet

Managing multiple containers

Docker Compose Issues

Layers for containers

Networking for containers

Docker Objects

Running Docker on Windows

Where you store and share container images

Cluster of nodes working together

Doing a dry run using check

Dynamic Configurations

Dynamic Data Masking in Azure SQL

DynamoDB and Implicit Dependencies

Based on naming convention, pricing, and purpose.

ENIs, ENAs, and the sorts

EBS and EFS

Eclipse

ECR and Provisioners

EKS Networking

Elastic Cloud

Overview of Amazon EKS

How ELB Works

Elastic Stack

Elastic Stack Labs

Basics of Elasticsearch

Elasticsearch SQL

Securing your Loadbalacers

Enabling API versions

Environment Variables

Error “AADSTS16000” When Logging in

Error Guides

Error Handling

Error Pages

Error: Failing to Delete CloudFormation Stack

etcd Default Server Port

Execute Script Install httpd and Edit a File

Execution

Exporters in Prometheus

Kubernetes visibility through Falco

Overview

File Persistence

Using security groups in Azure

Final Project

A guide in designing and running workloads in the cloud

Flattened Data Type in Elasticsearch

Starter Notes on Flux CD

Forward Auth

Amazon FSx and AWS DataSync

Using Analyzers to Cotrol Full-Text Search

Functions in PromQL

Functions

Fuzzy Matching in Elasticsearch

Overview

First things you need to know

Generator Plugin

Generators

GitOps Basics

Introduction to GitOps

Glance – Image Management

Go Cheatsheet

Packages, Modules, and Main

Health Checks

Heartbeat Plugin

Using Helm as an Alternative

Helm Chart and Templates

Helm Cheat Sheet

Helm Package Manager

Helm with FluxCD

Using Heroku

High Availability

Using HMAC Authentication in Kong

VirtualBox NOtes

Easy to follow checklists for helpful automations

Prometheus HTTP API

Using Let's Encrypt HTTP Challenge

HTTP Get Client Application

HTTP Poller Plugin

HTTP Repositories

HTTPS and TLS

Authentication and Authorization in EKS

Identity and Access Management

Setting up VS Code for Development

Microsoft Identity Platform

Importing CSV Data

Importing JSON Data

Search Indexing

OpenStack Control Plane and Infrastructure Planning

Securing your AWS Infrastructure

Prepare the Infrastructure Services

Ingesting Logs from S3

Initial setup for GCP

User Input and Output

Inputs and Port Mapping

Install and Configure Tomcat as the Staging Environment

Overview

Install Docker Compose

Install Docker Desktop

Install Docker on RHEL/CentOS

Install Docker on Ubuntu

Install Docker on WSL2 without Docker Desktop

Install Docker Sandboxes (SBX) CLI on Windows Subsystem for Linux (WSL)

Overview

Overview

Overview

Install Kong

Overview

Overview

Install Terraform on Windows Server

Installation

Installation Checklist

Installing CentOS Apache Role from Ansible Galaxy

Installing gitconfig Role from Ansible Galaxy

Installing Kustomize

Installing Logstash on a Virtual Machine

Installing Maven

Installing Prometheus on virtual machines

Instrumentation

Introduction to Observability

Inventories and Configuration

Inventories and Configuration

Jobs and CronJobs

JSON Search

Using JWT Authentication in Kong

Using Key Authentication in Kong

Keystone – Identity Service

Kibana by Example

Kibana Canvas

Kibana Features

Kibana Lens

Kibana Management

Killercoda

Introduction to Kong API Gateway

Kubeconfig File

Kubelet Security

Container Management Challenges

Kubernetes API Objects

Container Management Challenges

Kubernetes Ecosystem

Kubernetes in the Cloud

Kubernetes Ingress

Kubernetes Networking

Kubernetes Patterns for Application Developers

Services, ClusterIP, NodePort, and LoadBalancers

Kustomization File

Starter Notes on Kustomize

Lab Setup and Installation

Lab Setup Templates

Lab Walkthroughs

Lab: Operations

Labels, Selectors, and Annotations

Run code without provisioning servers

AWS Lambda and SQS patterns with Terraform

Improving Lead Time

Least Privilege Principle

Lifecycle & Observability

Using a plugin to limit and terminate requests

Limit Node Access

Leveraging linux features

The Linux kernel enhances resource management.

Linux Privilege Escalation

LoadBalancers in EKS

Log Analytics

Container Logging

Logging and monitoring options in AWS

Control Plane Logging to CloudWatch

CloudWatch Logs and Insights

Logstash with MySQL

Lookup Function and Variable Types

Loops

macOS Gatekeeper Error for Unverified CLI Binaries

Managed Identities

Tools for managing Azure resources

Managing Directories

Detecting and remediating incidents

Configuration file for resources

Mapping Exceptions in Elasticsearch

Mappings

Metrics

Metrics

Metrics in Prometheus

A 10,000 ft view of Microsoft Azure

Microsoft Graph

Middleware

Best practices for securing container images

Minimize IAM Roles

ML2 Plugin – Modular Layer 2

Modules Deep Dive

Monitoring a Storage Account

Multi-Line Logs

Multi-Stage Builds

Mutable and Immutable Infrastructure

Indexing with N-grams in Elasticsearch

Network Policy

Overview

Networking and compute patterns with Terraform

Configure Networking and Security

Networking Security

Neutron – Networking

New Subscription shows Zero Credit

nodeSelectors and nodeAffinity

Lessons learned from 'The DevOps Handbook'

Nova – Compute Management

Observability

Offline Install

Authenticating client and server communication

Enforcing policies across systems

Manual OpenStack Installation in Virtual Machines

Operators in PromQL

Optimizing Performance

First things you need to know

Pagination

Parsing and Filtering with Grok

Partial Matching in Elasticsearch

Persistent Volumes

Persisting Data

Phrase Search

Placeholder

Placeholder

Planning your costs in Azure

Playbook on Ping

Playbook on sending gitconfig

Playbook on Uname

Playbooks

Playbooks and Modules

Playbooks Modules

Container Management Challenges

Container Management Challenges

Security rules for pod deployments

The building blocks of Kubernetes

Product is live. What's next?

Practice Inventory

Practice Modules

Practice Playbooks

Practice Variables Conditionals Loops

Practice Yaml

Pre-requisites for Container Labs

Connecting privately through a network interface

Using a Private OCI Registry (GitLab)

Private Repositories

Probes and Multi-Container Pods

Project 001 Ansible Basics

Project 002 Ansible Roles

Project 003 Confluent Cloud

Project 004 Ecommerce LAMP

Project 005 Maven Sample

Projects and Labs

Basics of Prometheus

Prometheus Labs

Prometheus Monitoring with Traefik

Using Prometheus Plugin in Kong

Prometheus Query Language

Providers

Traefik Providers

Terraform provisioners and deployment packaging

Kubectl Proxy and Port Forwarding

Using Proxy Caching plugin in Kong

Public OCI Repositories

Batch Jobs and PushGateways

Query Lite Interface

Setup Go in Minutes

Rate Limiting

Receiver and Notifiers in Prometheus

Recording Rules in PromQL

Redirect Scheme

Reducing costs in your Azure solutions

From locally-redundant to geo-zone-redundant storage

Registry

Remove Obsolete Packages and Services

ReplicaSets and Scaling

Resources, bookmarks

Restrict Kernel Modules

Restrict Network Access

Limiting the access on your S3 Buckets

Role-Based Access Control

Roles, Templates, and Vault

Rollouts and Rollbacks

Routers

Running PodInfo

Methods to encrypt S3

Optimize your S3 Buckets

Securing your S3 Bucket

S3 Storage Classes

Sample Pipeline

Detect security vulnerabilities in container images.

Scheduling Pods

Schema and Handler

Search as you type in Elasticsearch

Filter system calls to enhance application security

Storing sensitive information

Securing each step of the automation

Securing and Optimizing APIs

Securing Azure Solutions with Azure Active Directory

Securing Control Plane Communications with Ciphers

Securing the Docker Daemon

Security

Security Contexts

Using Security Plugins in Kong

Security Primitives

Self-managed vs. Managed Nodegroups

Server management done by the Cloud

Server management done by the Cloud

Service Accounts

Service Discovery

Services

Setting up the Lab

Overview

Setting Up Flux

Setting Up Git

Use Github Profile README to showcase your portfolio

Container Management Challenges

Setting Up Kubernetes using k3d

Setting Up Kubernetes using Kind

Steps to setup development laptop for new work projects.

Setting up Prometheus Exporters

Setting up VirtualBox

Shards

Sharing Data in Docker Compose

Service Level Agreement and Lifecycle Policy

Sorting in Elasticsearch

Todo

Todo

Todo

Todo

Todo

Todo

SQS and Lambda

Difference between the three services

SSH Hardening

SSL/TLS Configuration

Starter Notes on Terraform

State Management

Stateless and Stateful

Inspect container images for security issues.

Static Configurations

Pods managed directly by the kubelet

Status Codes and Restart Policies

GCP Storage Services

Storage Security

Subqueries and Histograms in PromQL

Syslog with Logstash

Adding tags to container images

Influencing the scheduling of Pods

Templates, Plugins, Execution, and Vault

Notes on Terminal and CLI Tools

Testing Alerts in Prometheus

Testing Grok Patterns

Testing with FastAPI Endpoints

Cloud Native Security

A guide to successful cloud adoption

Thinking like a Developer

TLS Basics

Using Let's Encrypt TLS Challenge

TLS in Kubernetes

Record of my current setup

Tracing

Tracing Linux Syscalls

Starter Notes on Traefik

Traefik API

Traefik Architecture

Traefik Dashboard

Traefik Labs

Traefik Logs

Using Transformer Plugins in Kong

Transformers

Troubleshooting

VirtualBox Conflicts with WSL

Troubleshooting Basics

Tools for troubleshooting, governance, and ensuring compliance

Twitter Input Plugin

Two tier Design Part 1 Package Management

Two tier Design Part 2 Install services

Two tier Design Part 3 Upload application to Web Servers

Two tier Design Part 4 Configure the LoadBalancer

Two tier Design Part 5 Health Check Status

Two tier Design Part 6 Consolidate into One Playbook

Two tier Design Part 6 Using Prompts

Two tier Design Using Ansible Roles

Two tier Design Using Include

Two tier Design Using Local Variables

Two tier Design Using Registered Variables

Two tier Design Using Variables

UDP Logs and ELK Stack Integration

Uninstall Docker

Uninstall Elasticsearch

Uninstall Kibana

Updating Data in Elasticsearch

Cloud Migration

Users Role

Using Ansible Vault

Importing data using Client Libraries into Elasticsearch

Using Docker Compose

Using Docker Swarm

Using Docker without Root Permission

Authentication and Authorization using Entra ID

Using host vars and group vars

Using Jinja2 Templates to Deploy /etc/hosts file

Using Jinja2 Templates to Deploy motd

Using Kolla-Ansible to Setup OpenStack

Using Packstack to Setup OpenStack

Importing data using Scripts into Elasticsearch

Using the Kong Admin API

Using the AWS Snow Family

Setting up Elastic Stack using Vagrant

Checking and enforcing policies with Admission Controllers

Variables and Constants

Variables Conditionals Loops

Variables, Conditionals, and Loops

Terraform variables, expressions, and common functions

Vector Matching in PromQL

Visual Studio Code Extensions

Visualization in Prometheus

Peering between virtual networks

Volumes and StorageClass

VPC with EC2 and NGINX

Seamless integration between on-premise and the cloud

Fix VS Code Remote SSH Source Control stuck scanning for Git repositories

Issues encountered on VSCode Source Control Extension

Security through Managed Firewall and API Gateway features

Webhooks for validation and modification policies.

Webservers Role

Docker containers

Limit image sources to trusted registries only.

Terraform workflow and CLI commands

Flux CD Workflows

WSL2 suddenly stopped working on both Command Prompt and Powershell

Zero Trust Concepts

Using Zipkin Plugin in Kong