# EDC4IT course outlines > The complete syllabus of all 57 EDC4IT courses, as plain text. > Summary and links: https://www.edc4it.com/llms.txt > Scheduled dates and prices: https://www.edc4it.com/training/open-enrollment --- ## Core Kubernetes Masterclass - Course code: K8S-CORE - URL: https://www.edc4it.com/training/course/core-kubernetes-training - Duration: 5 days - Categories: Kubernetes Training, DevOps Training - Languages: English, French, Dutch ### About this course Master Kubernetes with our comprehensive 5-day hands-on course focused on real-world implementation, architecture and best practices. Learn container orchestration, deployment strategies, scaling, and security through practical exercises with real production scenarios. Perfect for developers and DevOps professionals working with vanilla Kubernetes, OpenShift, Azure Kubernetes Service (AKS), Google Kubernetes Engine (GKE), or other K8s distributions. This course also provides excellent preparation for CKAD certification while prioritising actual workplace competencies. Hands-on training with enterprise-grade applications and industry best practices. ### Who should attend Developers and DevOps/platform engineers who need solid, working Kubernetes skills, whether you run vanilla Kubernetes, OpenShift, EKS, AKS or GKE. Also ideal for teams standardising their Kubernetes practices, and for engineers preparing for the CKAD exam. ### Prerequisites Students are expected to have basic knowledge of a Container runtime such as Podman or Docker. At a bare minimum students should be familiar with Images, Containers, Volumes, Repositories. We advise students to follow our DOCKER-4K8S course (or the full DOCKER-CORE) Though not required, it is helpful to have an understanding of linux and basis of networking . ### What you will learn - Understand the Kubernetes architecture and its core objects and resources - Deploy and operate workloads with Pods, Deployments, StatefulSets and other controllers - Configure applications with ConfigMaps and Secrets and manage storage with Volumes - Expose and connect services with Kubernetes networking - Apply security fundamentals including RBAC and API-server security - Customise deployments with Kustomize and use the day-to-day Kubernetes tooling ### Outline Unlock transformative potential with our Kubernetes course, delivered by expert instructors committed to your satisfaction. This course is not just an excellent gateway to the CKAD exam; it's an investment in your team's real-world capabilities. We prioritise project-focused skills over individual certifications, ensuring you gain essential workplace competencies. Whether you opt for a private course or a detailed online experience, whether you're using vanilla Kubernetes, OpenShift, Azure Kubernetes Service (AKS), Google Kubernetes Engine (GKE) or other distributions, elevate your department's professional standing with this game-changing offering. How does this course map to the CKAD requirements? - **Application Design and Build**: Fully covered during this course. Make sure you also have the skills as covered in our [Core Docker](DOCKER-CORE) course. - **Application Deployment**: Managing deployments (including canary) and helm are fully covered during this course. - **Application Observability and Maintenance**: This is a crucial part of the course. In addition to explaining the required concepts, students value the hands-on approach of this course that provides a lot of opportunities to debug, troubleshoot and monitor application behaviour. - **Application Environment, Configuration and Security**: You will be deploying real-life applications that require plenty of configuration and secrets. We'll also explore security and how to access the kubernetes API server using service accounts and hence have to set up the security for that. - **Services and Networking**: You'll get plenty of exposure to using and troubleshooting service access, including external services through ingress rules. We introduce network policy (full details of these policies are further explored in our [Kubernetes Admin](K8S-ADMIN) course.) We also offer a [Kubernetes Admin](K8S-ADMIN) course more geared towards Administrators, but is also valuable to Developers. ### Introduction #### Kubernetes - Introduction to kubernetes - Understand the need for **orchestration** - **History** of kubernetes - Kubernetes as a **microservice platform** #### Kubernetes Architecture - Understand the **Control Plane** architecture - Understand the components that make up **Master** and **Worker Nodes** - Understand the role of the **Container Runtime Interface** - Introduce master components **APIServer**, **Controller-Manager**, **Scheduler** and **etcd** - Introduce node components **kubelet**, **kube-proxy** and the container runtime - Discuss other components (**CoreDNS**, **dashboard**) - Discuss current CRI runtimes (**containerd**, **cri-o**) - Appreciate why Docker no longer works directly with Kubernetes (dockershim removal) #### Introduction to kubectl - Interacting with your cluster using **kubectl** - Appreciate the **declarative** nature - Use adhoc **imperative** commands - Configuring **clusters** - Managing **kubeconfig** - Setting up different **contexts** and switching between them - Basic kubectl **commands** - **patching** resources - use **service-side apply** (SSA) ### Kubernetes Objects and Resources #### Introduction to Objects - managing objects using **kubectl** - Understand different categories (**workload**, **services**, **config** etc.) - Using **yaml** to define objects - introduction to the **yaml syntax** - **Organising** YAML files - Understand **meta-data** - Appreciate **labels** (define and use them in **selectors**) - Use **annotations** to add additional information - Understand and use **namespaces** - Manage objects inside namespaces #### Workload and Service Objects Introduction - Understand and define **Pods** - Appreciate the power and ease of **ReplicaSets** - Understand how **Deployments** ease working with workload objects - Introduce **Services** - Understand the relation between **Service**, **Deployment**, **ReplicaSet** and **Pods** #### Pods - Understand the Pods **life-cycle** - Defining **container(s)** inside a pod - Understand container isolation (and what is shared, such as **IPC**, **UTS** etc.) - **Defining** pods using YAML - Understand how controllers may define pods (using **templates**) - Interacting with a pod (**logging**, **exec** commands) #### Deployments - Introduce the Deployment API - Define **ReplicaSets** to define **replicas** - **Changing** and **replacing** deployments - **Scaling** and **auto-scaling** deployments - Understand and change the **securityContext** - Triggering and Managing **rolling updates** - Managing **rollouts** (**revert** back, use and manage deployment **history**, etc.) - Discuss and appreciate **canary deployments** - Using **initContainers** for initialisation - Discuss the **side-car** pattern - Using **initContainers** for side-cars #### Services - Understand the problems solved by services - Appreciate **label selectors** - Creating **Services** using YAML - Understand the concepts of **EndpointSlices** - Understand basic **Service Networking** - Using **CoreDNS** to find service by name - Understand the difference between service types (**ClusterIP**, **NodePort**, **LoadBalancer**) - Accessing external services using **EndpointSlices** - Understand **session affinity** - Discuss and use **MetalLB** (cloud-native load-balancer) for on-prem clusters #### Managing Pods and Containers - Understanding the container's **environment variables** - Managing the **pods health** - Manage container **failure** (**restartPolicy**) - Using **probes** to monitor container availability (e.g., **startupProbe**,**livenessProbe**, **readinessProbe**) - **best practices** for probes (configuration, when not to use, impact on rolling updates etc.) - Setting up resource **requirements and limits** (CPU, RAM, storage) - Populating the environment using references (**fieldRef** and **resourceFieldRef**) - Setup **Quotas** - Discuss **security context** - Manage **UID and GID** of container processes - Discuss hardening **pod and container security** - use **Pod Priority** and **pod disruption policies** #### Auto-scaling - Introduce the different auto-scaling solutions (horizontal, vertical, cluster) - introduce the **Horizontal Pod Autoscaler** (HPA) - Understand the different types of HPA (resource/custom/external) - Discuss the **HPA algorithm** and various **time related** configurations (forbidden windows, sync periods, …) - Define **Resource** type HPAs - Define **custom** type HPAs (using prometheus) - Add scale up and down **behaviour** #### Ingress - Introduce **Ingress** - Using Ingress with **StatefulSets** - Configure **paths** - Using **subdomains** and virtual hosts - Setting up **TLS** and **SSL Termination** - Configuring reverse-proxy features: **CORS**, **DoS protection**, **Redirects**, … - Configure Ingress using **annotations** and **CRDs** - Explore **Traefik CRDs** - Use Ingress for **basic authentication** - Integrate external authentication (**OIDC**/**LDAP**) with Ingress #### Gateway API - Introduce **Gateway API** - Understand the **rationale and differences** with Ingress - Discuss the role-based approach - Define **Gateways** for your cluster - Define **HTTPRoutes** to manage traffic to applications - Discuss other protocols (e.g., **GRPCRoute**) - Use the gateway API for different **traffic management** scenarios - Use Gateway for authentication (**Basic**, **OIDC**/**LDAP**) - Explore **Envoy CRDs** ### Storage and Persistence(Volumes) - Introduce the concept and need for **volumes** - Using ephemeral volumes (**hostPath**, **EmptyDir**) - Introduce cloud storage via **CSI drivers**, replacing the removed in-tree `gcePersistentDisk`/`awsElasticBlockStore`/`azureDisk` plugins - Compare CSI driver examples for **AWS**, **Azure** and **Google Cloud** (EBS, Disk and PD CSI drivers) - List other standard volume types (**secret**, **configMap**, **downwardAPI**, **projected**, …) - Define and use **PersistentVolume** (PV) and **PersistentVolumeClaims** (PVC) - Understand the difference between **static** and **dynamic provisioning** - Statically provision PVs - Understand the implications of choosing **retention policies** - Appreciate the concept of **StorageClass** resources - Use dynamic provisioning of pvs - Choose **file vs block** volume types - Use **local** volume types for replication-aware applications (e.g., Kafka) - fix file permissions using **securityContext** ### Stateful Sets - Introduce **StatefulSets** (sts) - Discuss **scaling stateful services** (and use-cases) - understand the relation between **sts and persistent volumes claims** - Understand the role of **headless** (and "headful") **services** - Introduce and discuss **operators** to ease management of stateful services ### More controllers - Work with **DaemonSet** - Understand **Jobs** and recurring ones using **CronJob** - Monitoring CronJobs using a **job monitor** ### Configuration and Secrets - Introduce **configMaps** - **Defining** configMaps using YAML - Accessing ConfigMaps through the **environment** (using **envFrom**) - Mounting config data using **configMap volumes** - Reloading and dynamic config data - Understand the challenges of **sensitive data** - Introduce **Secrets** - Defining and using **Secrets** - Setting up a **private docker registry** (Nexus) - Discuss **secret management** (HashiCorp Vault/Sealed Secrets/…) ### Security ### API Server Security - introduce kubernetes **security architecture** - Understand the difference between human users and **service accounts** - List different **authentication** techniques (SSL certificates, tokens, etc) - Understand the use of **JWT tokens** - Using tokens inside the pods (**mounted secrets**) - Understand kubernetes **authorisation** mechanism (verbs/resources) - List different **authorisation modules** (**Node**, **RBAC** etc) - Assigning users to standard **ClusterRoles** - Using **CertificateSigningRequest** to sign user certificates - Introduce **Network Policies** - Allowing and Denying traffic **Ingress** and **Egress** #### RBAC - Explain **RBAC** - Understand and define **Role** and **ClusterRole** - Defining access **rules** - Binding roles to service accounts (**RoleBinding**/**ClusterRoleBinding**) - Accessing the **API Server from a pod** ### Kustomize - Introduction to Kustomize - Discuss the **benefits** of Kustomize - Understand **bases** and the **directory structures** - Understand **Resources** - Introduce low-level constructs (**generators**, **transformers** and **validators**) - List the **convenience** constructs - Force **labels/annotations** on resources - Managing **names** and **namespaces** - Defining **ConfigMaps** and **Secrets** - **Create**, **merge** or **replace** configMaps/Secrets - Using **vars** for basic **reflection** - Override Deployments **image**, **replicas** - Introduce **Patches** - Using **strategic merge** patches - Using **JSON 6902** patches - Introduce and use **Components** ### Tooling #### Introduction - Overview of common **stacks** - Appreciate **Operators** #### Helm - Introduction to **Helm** (helm 3) - Understanding **charts** - Installing and **configuring** releases - Rolling-out new versions #### Monitoring Prometheus/Grafana/Loki - Using **Prometheus** (Operator) - Understand the Architecture of Prometheus - Understand the structure of a **metric** - Discuss **instrumentation** techniques (using java, go , python, …) - Understand the different **metric types** (counter, gauge, histogram, …) - **Installing and configuring** Prometheus/Grafana (basics) - Discuss **federation** and scalability - List the **CustomResourceDefinitions** - Adding **Service Monitors** - Preparing applications to **expose** metrics (e.g., Spring Boot) - Using **exporters** - Using **Grafana** dashboards - **Importing** existing dashboards - Discuss and add **Loki** #### Kubernetes Operators - introduction to the **operator pattern** - Appreciate Custom Resource Definitions (**CRDs**) - Discuss implementation languages, platforms and SDKs (e.g., **operator SDK**, **kube-rs**, … ) - Discuss and use Database operators (e.g., **CloudNativePG**, **Crunchy Data**, **PGO**, **Zalando**, …) - **Use operators** in your cluster ### Frequently asked questions Q: Does this course prepare for the CKAD certification? A: Yes, it is excellent CKAD preparation, while deliberately prioritising the skills you use in real projects over exam tricks. Q: Which Kubernetes distribution does the course use? A: The course is vendor-neutral. Everything you learn applies to vanilla Kubernetes, OpenShift/OKD, Amazon EKS, Azure AKS, Google GKE and other conformant distributions. Q: What do I need to know before attending? A: Basic container knowledge (images, containers, volumes, registries) with Docker or Podman. Our DOCKER-4K8S or DOCKER-CORE courses are ideal preparation. Q: How is the course delivered? A: Live and instructor-led, online or at your premises, in English, French or Dutch. Groups are small (max 10 onsite, 7 online), and the 5 days can run consecutively or spread out. --- ## Kubernetes Administration & Configuration - Course code: K8S-ADMIN - URL: https://www.edc4it.com/training/course/kubernetes-administration-training - Duration: 4 days - Categories: Kubernetes Training, DevOps Training - Languages: English, French, Dutch ### About this course Designed for cluster administrators, this course covers essential Kubernetes setup and maintenance. It provides a solid foundation for the CKA exam while emphasizing real-world skills. Unlike many competitors, we focus on practical, project-based learning. Participants who complete the course will be well-prepared for both the exam and actual work environments. ### Who should attend Cluster administrators, platform engineers and operations teams responsible for installing, configuring and maintaining Kubernetes clusters, including those preparing for the CKA exam. ### Prerequisites Students must be familiar with using kubernetes and should have an understanding of the basic kubernetes objects such as nodes, pods, deployments and services. We recommend students to follow our Core Kubernetes course before attending this course. ### What you will learn - Understand cluster architecture and install a Kubernetes cluster from scratch - Configure and maintain clusters, including upgrades and etcd management - Monitor clusters and manage resources, requests and limits - Control workload placement with scheduling, affinity and taints/tolerations - Administer cluster networking - Prepare effectively for the CKA exam with real-world, project-based skills ### Outline This course is engineered for cluster administrators, offering comprehensive training in installing, setting up, and configuring a Kubernetes cluster. While it serves as an excellent primer for the CKA exam, its true strength lies in preparing participants for real-world scenarios. Unlike many competitors, we prioritise hands-on, project-centric skills. Participants who actively complete the course will be well-prepared for the CKA exam and, more importantly, will have the specialized expertise to make a meaningful impact in real-world operations. For those that are seeking certification, and wonder how this course maps to the CKA requirements: - **Cluster Architecture, Installation & Configuration**: this is the core of this course - **Workloads & Scheduling**: basics covered in [Core Kubernetes](K8S-CORE), define namespace wide resource limit defaults and scheduling details (e.g., affinity, toleration's etc.) are covered during this course. - **Service & Networking**: basics covered in [Core Kubernetes](K8S-CORE) while CNI and network policies are covered in this course - **Storage**: mostly covered in [Core Kubernetes](K8S-CORE). During this course we explore on-prem storage solutions - **troubleshooting**: application troubleshooting is part of [Core Kubernetes](K8S-CORE), during this course we cover general cluster and nodes related problems During the workshop, students will set up and configure a 5-node kubernetes cluster with a HA control-plane. ### Cluster Architecture - Recap of k8s architecture (**Master** and **Worker Nodes**) - Recap **control plane** components (APIServer, Controller-Manager, Scheduler and etcd) - Choosing a **container runtime environment** (docker, containerd, cri-o) - Discuss the role of **Container Network Interface** (CNI) - A deeper dive into the role of **etcd** - **Planning** a cluster (e.g, size, machine types, etc) ### Installation - Discuss different installation techniques (kubeadm, kops, …) - Using **kubeadm** to install a cluster - Set up a **control plane** - Using your **own image registry** for the control-plane (and cluster) - Discuss **Admission Plugins** - Installing a **CNI** implementation - Set up an initial **worker nodes** - **Adding masters** to your cluster - **Configuring** kubeadm using YAML - Setup a **HA etcd cluster** - understand **etcd** - Introduce **raft** (consensus algorithm) - Topologies for **Highly Available clusters** (HA) (stacked vs external etcd nodes) #### Configuring Role-Based Access Control (RBAC) - recap **RBAC** - Planning user-access - User access **workflows** - Managing cluster administrators and **users** using RBAC - Limiting object and namespace **access** - Using OpenID (**OIDC**) to authenticate cluster users - Integrating with **LDAP** ### Configuration - Configuring your k8s installation - Introduce etcd admin tools **etcdctl** and **etcdutl** - **Backing up** your etcd configuration - **Scaling** worker nodes (adding/removing nodes) - Discuss **Upgrading** strategies - **Upgrade a cluster** to a new k8s version - General Configuration tuning Best Practices - Installation and configuration troubleshooting - **Encrypting secrets at rest** (etcd) ### Monitoring #### Monitoring using Prometheus/Grafana - Using **Prometheus** - **Installing and configuring** Prometheus/Grafana (basics) - Discuss **federation** and scalability- - Understand prometheus **Service Discovery** - Using prometheus **relabeling** - Understand the structure of a **metric** - Understand the different **metric types** (counter, gauge, histogram, …) - Adding **Service Monitors** - Using **Grafana** dashboards - **Importing** existing dashboards #### Log aggregation with Loki - introduce **Loki** - Understand the Architecture of Loki - Appreciate the **indexing behaviour** of Loki - Discuss the benefits of using Loki over other logging solutions - Discuss Loki **configuration** (promtail, storage, scraping, …) - Setting up Loki using helm #### Storage - Recap **volumes** - Reiterate the difference between **static** and **dynamic** **storage provisioning** - Setting up **storage classes** - Discuss **on-prem dynamic storage** solutions - Setting up a distributed storage solution (**Rook/Ceph**) - **Monitoring** storage ### Workloads & Scheduling ### Resources - recap of container resources (requests/limits) - setting up **default resource limits** per namespace - Define and manage resource **sonatas** - Monitoring workload resource ### Pod Scheduling - Introduce the **node selection** process - Scheduling pods to nodes using **node selectors** - Keeping pods away from nodes using **taints** and **tolerations** - Inviting pods to nodes using **affinity** - Co-locating (or not) pods using **podAffinity** and **podAntiAffinity** ### Networking - Recap networking objects (services, ingress, …) - Discuss **kubeproxy** - Using **LoadBalancer** service types for on-prem clusters #### CoreDNS - overview of *core-dns* - recap of *DNS records* in kubernetes (A/AAAA/SRV/CNAME/…) - Understanding the *default configuration* - Configure **upstream nameservers** - Configure **logging** #### Kube proxy - recap the role of kube-proxy - explore different **modes** (iptables, ipvs) - understand how kube-proxy uses **iptables** - discuss issues with using **iptables** - **performance** tuning for iptables mode - configure and explore **IPVS** - use different IPVS **schedulers** #### MetalLB - Introduce **MetalLB** as a load-balancer for on-prem clusters - Understand the architecture of MetalLB - Pros and cons of **Layer-2** vs **BGP** - Confusing IP pools for **MetalLB** - Using **MetalLB CRDs** #### Network Policies - Explain **Network Policies** - Understand the default behaviour in kubernetes - Protecting your Network - Protecting your Pods - Allowing and Denying traffic **Ingress** and **Egress* - Isolating **namespaces** - Allowing based on **pods** and/or **namespaces** - Allowing based on **IP Addresses** - **Port** level access - Policy **Patterns** ### Technology stacks (Discussion) - Recap Cluster Observability and **monitoring** - Recap Cluster **logging** (ELK/Elastic Stack, Kibana, Loki, Grafana) - RecapResource and **performance monitoring** (Prometheus, Grafana) - Reiterate the importance of **gitops** - Discuss solutions for **Secrets** - Tools for **Managing certificates** - Using **replication** for namespace-bound objects - Other tools ### Frequently asked questions Q: How does this course map to the CKA exam? A: Cluster architecture, installation and configuration (the heart of the CKA curriculum) is the core of this course, complemented by workloads & scheduling, networking, monitoring and troubleshooting. Participants who actively complete the labs are well-prepared for the exam. Q: What is the difference with the Core Kubernetes Masterclass? A: K8S-CORE teaches using Kubernetes as a developer/practitioner; this course teaches running it: installing, configuring and operating the cluster itself. We recommend following the core course first. Q: How is the course delivered? A: Live and instructor-led, online or at your premises, in English, French or Dutch, in small groups (max 10 onsite, 7 online). --- ## Cloud native computing: MSA, Containers and Kubernetes for Non Technicals - Course code: K8S-NONTECH - URL: https://www.edc4it.com/training/course/K8S-NONTECH - Duration: 0.5 day - Categories: Kubernetes Training, DevOps Training - Languages: English, French, Dutch ### About this course This course provides insight for non-technical stakeholders into Cloud-native computing, Microservices Architecture, Containerization (such as Docker), and Kubernetes. Its goal is to make you understand what they entail, what necessitated them, and the value they can add to your company. ### Prerequisites There are no pre-requisites to this course other than familiarity with general software development and IT. ### Outline Containerization is one of the most important developments in the industry, and its impact is far-reaching. It is hard to imagine what we, as an industry, would have done if it had not come at the right time. After its inception, containerisation presented a new set of problems that needed to be addressed. This is where, as an IT community, we introduced solutions such as Docker Compose, Docker Swarm, and eventually Kubernetes. Later on, the term cloud-native computing was coined to cover all the above technologies. ### The Problem Definition #### The long road to MSA In this first part, we look at the current state of our IT Architecture and dive into how we got here by laying out the gradual evolutionary process. We started this road at the tail-end of the eighties, just before application-centric. This section will cover the following: - The benefits and challenges of **client/server** architecture - The move to **application centric** architectures - the birth of **services** and **components** - Values and problems of **Component-Based Design** - The force of **low coupling** (one of the drivers for architecture) - The era of **Enterprise Application Integration** (EAI) and **Integration Patterns** (EIP) - **Event-Driven** and **Message-Oriented** architectures - The rise of the **Service-Oriented Architecture** - Promises made by **Enterprise Service Bus** (ESB) and the fall of SOA - the dawn of **Micro Service Architecture** (MSA) - Values and characteristic of the MSA #### Technical revolutions and eventual freedom In this section, we take a look at a second driver/dimension that led us to where we are and how it led to the birth as well as the immense popularity of Docker. This journey starts during the height of application-centric architecture in the mid-nineties. Here, we’ll cover the following: - From **CORBA** (Common Request Broker Architecture) to the rule of Java Enterprise - The ages of the (Java) **Application Server** (WebSphere, WebLogic, JBoss, Glassfish, Tomcat, OC4J) - The introduction of **deployable components** - Finally, competition, Microsoft joins with **.Net** - The value for **IT and Operations** - The stifling effect on IT Projects - The rise of (multiple) **technology stacks** - The **technology matrix hell** - The need for more agility and **constrained freedom** - Redefinition of "separation of concerns" ### Containerisation In this part, we explain what containerisation is and how it solves the problems we have discussed so far. Here is what we’ll cover: - Recap of the **problems** solved by Containerisation - What **embodies** a container ("what's in it"?) - The role of **Virtualization** and its role in containerised environments - The definition of **containers** and **images** as well as the relation between the two - **Docker-compose** and the depleted soil of **Docker Swarm** - The required **infrastructure** for images - The impact of the containerisation on the **software delivery processes** - **Risk mitigated** by Containerisation - Containerisation, MSA, and a call for **DevOps** ### The Crucial Role of Kubernetes MSA and containerisation have their own challenges when used with traditional IT application platforms and deployment strategies. This is where Kubernetes comes in. In this section, we’ll cover the following: - **Challenges** addressed by Kubernetes - What is **Orchestration**? - Choosing between **on-premises** or **cloud-based** Kubernetes clusters - A discussion on **cluster sizes** - **Security** in Kubernetes - Cluster Observability and **monitoring** - Cluster **logging** (ELK/Elastic Stack, Kibana, Loki, Grafana) - Resource and **performance monitoring** (Prometheus, Grafana) - A quick rundown of popular tools (**helm**, **Kustomize**, …) - A discussion on DevOps and **Gitops** - The possible need and role of a **Service Mesh** ### Standardisation Lastly, we’ll cover the following crucial enablers: - Appreciate the Open Container Initiative (**OCI**) - The role of the **Linux Foundation** - Container runtime abstraction: **CRI** (Container Runtime Interface) - Container Network Interface (CNI) --- ## Scala Cats and Cats-Effect 3.x - Course code: SCALA-CATS - URL: https://www.edc4it.com/training/course/SCALA-CATS - Duration: 2 days on-site, 3 days online - Categories: Scala Training, Programming Language Courses - Languages: English, French, Dutch ### About this course With this course we will be covering a range of topics that will give you a solid grounding in Scala Cats and Cats-Effect 3. Not only will you receive an introduction to Category Theory, Cats, Cats Effects, but we will also go through Tagless Final Encoding to give you a well-rounded overview. This course has been designed to give you as comprehensive an introduction as possible while still leaving time and space for questions and discussion. ### Prerequisites Students should be familiar with the Scala programming language (preferable version 3). You should in particular be familiar with aspects such as type-classes and context bounds. It is a great course for student preparing to use Scala libraries such as fs2, http4s, ZIO, AKKA/Pekko etc ### Outline ### Scala Recap (if needed) - Type constructors - Higher-kinded types - Type classes in Scala - Context bounds ### Introduction to Cats - Understand the **scope and intent** of Cats - Explain the **structure** of the library - List cats **modules** - Various **import** approaches - List and discuss **related** projects - Using a **Cats Type class** - Defining **your own instance** - Discuss **ID Operations** - List various small **enhancements** to Scala (e.g, for `Either`/`Option`) - Introduce **Monoids and Semigroups** ### Overview of Category Theory - Introduce Category Theory for Developers - What is a **category** - Understand **objects** and **morphisms** - Define **composition** and **associativity** - Introduce the **identity** arrow - Introduce the term **Hom-Set** - Discuss **Example Categories** (0, 1, 2, Monoid, Set) - Understand the **category of types and functions** - Discuss and implement **Kleisli** as an example - **Initial** and **Terminal** Objects - Discuss the concept of **Universal Construction** - Discuss and implement **Product Types** - Introduce **natural transformations** ### Cats Functors, Applicatives, Traverse and Monads #### Functors - Introduce **Functors** in terms of Categories - Use **Endofunctor** in Programming - Introduce the **functor laws** - Introduce the **Cats Functor Type class** - Using derived methods (**lift**, **as**, …) - Introduce **Natural Transformations** - Understand **FunctionK** - **Combing Functors** using the `Nested` type - Introduce **Bifunctors** - Using bifunctors with ADTs #### Applicatives and Traverse - Introduce the **Applicative** functor - compose **independent effects** - Using **product**/**tuple** functions - Using **mapN** functions - **Replicating** Applicatives - **Composing** Applicatives - Introduce **Traverse** - Using Traverse **sequence** #### Monads - Recap **Kleisli** - Introduce **Monads** - Introduce the **monad laws** - **composing dependent effects** using Monads - Writing **tail-recursive** Monads ### Cats Core Data Types #### Validated - Using **Validated** to accumulate errors - Understand the role of sequence - Using the **Chain** and **NonEmptyChain** #### Parallel - Understand the need to **Parallel** - Recap **FunctionK** and **Natural Transformations** - Using parallel operations on Monads (e.g, **parProduct**, **parSequence** etc) #### Eval - Using **Eval** to control synchronous evaluation - Understand the concept of **trampolining** - Understand the concepts of `now`, `later`, `always` - Using **defer** to lift a value into 'Eval' #### Monad Transformers - Understand the role of Monad Transformers - **Composing Monads** using Transformers - Use transformers to **stack effects** - List bundled transformers (**OptionT**, **EitherT**, ..) - **Caveats** and alternatives #### Reader, Writer and State Monads - Turning functions into monads using **Reader** - Use the Reader for implicit **contextual objects** (e.g., configuration) - Using the Reader for **dependency injection** (with effect tracking) - Using **ReaderT** to stack other effects - Understand the relation between **Reader**, **Kleisli** nad the identity monad - Introduce the **Writer monad** - Using the writer for audit trails ### Raising and Handling Errors - Introduce the **ApplicativeError** and **MonadError** - **Raising** errors - **Handling** errors - **Transforming** errors (e.g, to `Either`) - Using an error-**tap** ### Dealing with Side Effects (Cats Effect) - What are **effects**? - Challenges with effects and Functional Programming - Side effects and **Referential Transparency** - Introduce Cats Effect - Understand the relation with Cats #### Introduce the IO Monad - Introduce the **IO Monad** reference implementation - **Trampolining** and IO - Understand the different execution styles (pure, lazy, async) - Introduce **Fibers** - Understand **non-preemptive multitasking** - Understand the problems with **JVM Threads** and Concurrency - Introduce green-threads and **fibers** - Discuss best practices for application **thread-pools** - Introduce the **IOApp** and **IOApp.Simple** #### The Effect Type Classes - Provide an overview of the Cats effect type classes (**MonadCancel**, **Spawn**, **Concurrent**, **Sync**, **Async** etc.) - List and introduce the other type classes (e.g., **Unique[F]**, **Clock[F]**, …) - Using **Console[F]** from the Cats effect standard library - Writing **polymorphic code** using context bounds - Discuss logging (**log4cats**) #### Cancellation (MonadCancel[F]) - Recap **MonadError** - Understand the concept of fiber **cancellation** - Apply masking using **uncancelable** - Appreciate the concept of **polling* - Introduce the **Bracket** use case - Understand **nested** brackets #### Resource (Data type) - Introduce and use the **Resource** type - Building **Resources** - **Composing** Resources #### Sync[F] - Recap the type-classes on which `Sync[F]` is based - **Suspending** effects - Suspending **blocking** effects - Building **cancable** blocking effects - Understand context **shifting** #### Suspending fibers (Temporal[F]) - Understand the concept of **semantic blocking** - Using combinators such as **sleep**, **delayBy** etc. - Using alternative effects in **time-outs** #### Fibers (Spawn[F]) - Recap **Fibers** - **Creating** fiber using `Spawn[F]` - Understand the `Spawn[F]` algebra - **Joining** multiple fibers - **Cancelling** fibers - Understand the `Fiber` **OutCome** - **Race** multiple fibers - Appreciate the **Parallel** implementation for `Spawn[F]` - Recap `Parallel[F]` - Using `Parallel[F]` with `Spawn[F]` (**parMap**, **parTraverse**, etc.) #### Concurrent State (Concurrent[F]) - Introduce the `Concurrent[F]` type-class - Using **Ref** to **share mutable state** between fibers - Understand `Ref` and **the benefits over traditional locking** - Appreciate **atomic updates** to the `Ref` - Using **Deferred** communicate between fibers - Understand the **difference** between `Ref` and `Deferred` - Discuss **various scenarios** for using the constructs - **Memoization** effects using `Concurrent[F]` - Using **bounded** versions of **Parallel** operations (e.g., **parReplicateAN**, **parTraverseN** etc.) #### Asynchronous effects (Async[F]) - Introduce the `Async[F]` type-class - using **callbacks** for asynchronous code - Add **cancellation** and **finalization** to asynchronous code - Integrate with legacy **Futures** and **CancelableFuture** - Understand **context shifting** - Shifting between **thread pools** ### Tagless Final - Understand the **theory** behind TF - Discuss **Initial vs Final** encoding - Appreciate **Tagged vs Tagless** - Encode your algebra using TF - Discuss **laws** - Using TF with Cats/ Cats Effect - Discuss various **Encoding** styles (functions, modules, traits etc) --- ## Core Scala 3 Masterclass - Course code: SCALA-CORE - URL: https://www.edc4it.com/training/course/scala-3-training - Duration: 4 days - Categories: Scala Training, Programming Language Courses - Languages: English, French, Dutch ### About this course This is a great course that familiarises developers with The Scala Programming language (Version 3.x, previously known as Dotty). This fresh and comprehensive course equips developers with all the tools necessary to function as a successful and productive team member on all Scala 3 projects. ### Who should attend Developers coming to Scala from another language (Java, C#, Rust, TypeScript, Python, ...) who need to become productive members of a Scala 3 team, and teams adopting Scala 3 for new projects. ### Prerequisites Students should be familiar with another programming language such as Java, C#, C++, Rust, Javascript/Typescript, Python etc. Having knowledge of a typed language will be beneficial. ### What you will learn - Read and write idiomatic Scala 3 code with the current syntax - Model domains with classes, objects, traits and algebraic data types (ADTs) - Program with functions and Scala's functional core - Work effectively with the Scala collections library - Use core effects and understand Scala 3's advanced type system features ### Outline This is not an upgrade course to Scala 3, but instead a course for newcomers to Scala who want to dive immediately into the latest version. We have an upgrade course available as well: [SCALA-UPGRADE-3](./SCALA-UPGRADE-3). If you are looking for a Scala 2 course, we recommended [SCALA-CORE2](./SCALA-CORE2) We are aware that many teams and developers follow Scala courses using recorded session or perhaps live webinar type of training and even more so during pandemic and economic crises. These kinds of courses are great for learning *products* and *easier concepts*. However, they don't lend themselves to understanding new and often **difficult concepts** as they don't allow the ability to ask **your own questions**. Everybody is **unique** in their ability to comprehend and understand new concepts. And everyone needs a **personalized approach**. In addition, hearing questions/concerns from **other students** can help you tremendously. There might be ideas and answers you haven't thought about. Even **without** you asking a question, an instructor on a live instructor-led course will see from **non-verbal communication** that a particular concept needs to be rephrased, needs a different diagram or example or needs to be revisited later. EDC4IT has been working with Scala since the early 2000s, and has taught many teams. We worked together with different teams on their projects. This course covers: - Introduction to Scala, tools and the language - Using OO concepts - Functional Programming with Scala - Higher kinded Types - Collections - using and building ADTs (using enums and traits) - Bundled Monads and Functors - Error Handling - Concurrency and Futures - Type bounds and variance - Implicit conversions and extension methods - Type classes - Opaque type aliases This course is unique in: - being not just example driven, but bringing a deeper understanding of the Scala language - explaining concepts that are often challenging in a clear manner (illustrating many approaches to different issues with the help of useful diagrams) - focusing on preparation for real-world projects (discussing real problems, caveats, best practices) ### Introduction - Introduction to the Scala language - Understand **key features** of the language - Scala on the **JVM** - Scala versions and Java Requirements - Using the **Scala CLI** - List popular scala tools (sbt, ammonite, scalafmt, …) - Introduction to the **Scala REPL** - Using the **scala CLI** - Introduce **sbt** to set up a project ### Language Basics - Explore **lexical syntax** - Explore scala's **literal values** - Understand basic **declarations and definitions** (`var`, `val` and `def`) - Declaring and using **variables** - Understand **basic types** (Integers, floating point, …) - Types with fixed cardinality (`Nothing`, `Null`, `Unit` and `Boolean`) - Enable and use **Explicit nulls** - Working with **Strings** - Program using **significant whitespace** (aka "optional braces") - Defining and Using **union types** #### Method and functions - Explore the **methods** syntax - Understand aspects such as **multiple parameter clauses**, **default values**, **repeated parameters** - Appreciate type **inference** - Understand **function application** ("calling" functions) - Explore more **expressions** (e.g, `if`-expressions) #### Recursion - Use **recursion** to problems - Learn how to **recognise** recursive solutions - Recursion and the stack - Explain *tail-call*, its elimination and in particular **tail recursive** ### Classes and Objects - Understand scala's hierarchy (`Any`, `AnyVal`) - Understand the **bottom types** `Nothing` and `Null` - Use scala's **explicit nulls** - Understand (multiversal) **equality** - Understand the difference between **objects, classes and traits** - Understand the difference between **instances and objects** #### Classes - Be able to **define classes** - Appreciate the **access modifiers** and further qualification - Adding **fields and properties** - Recap **methods declarations** - **infix notation** (and **symbolic** methods) - Define **constructors** (primary and auxiliary) - Method **overloading** - Define **type aliases** - Understand class **inheritance** (nominal sub-typing) - Be able to apply the **Liskov Substitution Principle** - Allow concrete classes to be extended using **open classes** - Prevent ad-hoc extensions using **final** - Concepts such as **abstract** members and **overriding** (methods and vals) - Discuss **composition over inheritance** - Understand the benefits of the **Law of Demeter** - Introduce **export** clauses #### Objects - Define **Objects** in Scala - Understand the concepts of **Companion Objects** and their typical use - Understand the **apply** and **unapply** methods #### Case classes - Appreciate **case classes** - Discuss **immutability** - "updating" objects and **immutability** - Understand **use-cases** for case classes #### Value Classes - Define **value classes** - Why you should not use **simple types** (String, Int etc.) - Understand caveats with value classes #### Packages - Organise classes/objects in **packages** - Discuss different styles of **importing** packages and classes/objects - Appreciate the **top-level definitions** - **renaming** imports - Organising your code #### Creating Applications - List the two ways of creating applications - Using **@main** to define an application - Use the legacy **main** methods - Dealing with *application arguments** ### Traits - Introduce traits - Discuss the principle of **mix-ins** - Different ways of mixing in traits - Use traits to enrich interfaces of other types - Discuss **sealed types** - **Solve** problems when mixing in **traits with params** - Appreciate **transient** traits - Understand the **linearisation** process - Solve **conflicts** - Understand the **stackable trait** pattern - Discuss **abstract classes** and traits - Defining and using **intersection types** #### Type Constructors (Introduction) - Understand the different **kind of types** - What are **higher-kinded** types - Appreciate **type constructors** - Mixin traits with type constructors (e.g., `Ordered`) ### Functions #### Theory - Understand **domain**, **codomain** and **image** of a function - Discuss different types of functions: **injective**, **Surjective**, **Bijective** and **Partial** - Understand the **arity** of a function - Properties of a function - Functions as **values** #### Functions in Scala Introduction - Defining **functions** - Difference between **functions and methods** - Use methods on functions (`compose`, ...) - The **function literal** syntax - The **function type literal** syntax - Use **Lambda expressions** - Using methods as functions (**automatic η-expansion**) - Functions as **objects** (e.g., `Function0`, `Function1`, …) - Function **composition** - Early return using **boundary** and **break** #### High-order function - Understand the concept of **Higher order functions** - Accepting functions and parameters - returning functions from functions - Understand **clojures** - Discuss various use cases - Using **placeholder** syntax (understand the expansion) - Understand **by name** parameters #### Currying - Appreciate **currying** (methods and functions) - Discuss use-cases - Use **partial function application** - Using **optional partial application** ### ADTs #### Introduction - Rethink the concepts of Types - Types (e.g., case classes) and their **cardinality** - Introduction to Algebraic Data Types (**ADTs**) - Understand the concept of **product types** - Introduce **Pairs** and their projections - Introduce **coproducts** (aka **sum types**) - Defining **coproducts** - **Algebra** with product types - A categorical view of ADTs - Parametrised ADTs - Mention and discuss Generalized algebraic data types (**GADT**) #### Enums - Introduce **enums** - Using enums as simple **named values** - Using enums for sum/coproduct ADTs (vs. traits) #### Pattern Matching - Introduce the power of pattern matching - Understand **various patterns** - Understand the role of **case classes** - Build **extractors** - Understand **sealed traits** - Pattern matching on ADTs - Understand pattern matching in value definitions - Introduce the concept of **Partial Functions** #### Optional Values - How to abstract the **absents of a value** - Problem with using bottom values such as **null** - Using the **Option ADT** - Using `Option` in your programs - How to use option with **side effects** - Using option as a **Functor** (mapping with `map`) - Using option as a **Monad** (sequentially compose using `flatmap`) - Introduce **for-comprehensions** - Adding **definitions** and **guards** ### Collections #### Introduction - Understand the type hierarchy (`IterableOnce`, `Iterable` etc.) - Understand the collection's architecture - Understand the role of **ops** types (e.g., `IterableOnceOps`) - Mutable and immutable collections - Creating collection instances - Collections and **equality** - **Ordering** collections - Integrating with JVM collections - Using **for-comprehensions** on collections #### IterableOnce and Iterable - Using collections as functors (mapping using `map`) - **Getting** elements from the collection - **Finding** and **Filtering** elements - Using partial functions to **collect** elements - **Adding** elements to a collection - **Splitting** and **combining** collections #### Seq - Working with indexed collections - **Searching** for elements - **Adding** to the head or the tail - **Replacing** elements - **Sorting** indexed collections - **Comparing** and using **set-operations** on collections - Discuss implementation and each of their benefits - When to use **Vector**, **List** and other implementations - Discuss **performance** consideration (operations and big-O) #### List as a GADT - Understand concepts such as **head**, **tail**, **Cons**, **init**, … - Using **Cons** to construct a list - **Pattern matching** Lists #### Sets and Maps - Working with **Sets** - Performing set operations (intersection, union, …) - **Adding and removing** set elements - List various implementations and their benefits (`TreeSet`, `HashSet`, …) - Discuss different algorithms and their performance - Using **Map** - **getting**, **updating** and **iterating** over maps - Map implementations (`TreeMap`, `HashMap`, …) and their **perforce** #### Folding and Reducing - Using **reduction** - Using associative **folds** using monoidal reduction - Using linear fold using an **initial value** - Understand the difference between **reduce and fold** - Understand the role of the **natural element** in folds - The difference between **fold, foldRight and foldLeft** - When to use which - Using **scan** ### Core effects #### Errors - Understand Errors and **exceptions** on the JVM - Using JVM exception in Scala - Using the **Try** ADT instead - Working with the Try ADT as a functor (`map`) - **composing** using `flatmap` - Translating to other ADTs - Discuss the various ways of **recovery** - Using the **Either** ADT - Using `Either` as an **alternative** for errors - Building your own **error ADT** - Translating errors. #### Concurrency and Futures - Understand the difference between **concurrency and Parallelism** - Understand **JVM Threads** and its **pools** - Using **Futures** for concurrency - Understand the role of the **Execution Context** - **Lifting** values into a `Future` - Using `Future` as a functor/monad - Working with **side effects** after completion - Handling and recovering from **failures** - **Combing** futures (fold, zip, …) - Appreciate **Traverse** and **Sequence** ### Advanced Types #### Higher-kinded types - Recap **Higher kinded** types - Introduce **polymorphic methods** - Define **polymorphic function types** - Type bounds (**Upper**, **Lower** and **Context**) - Introduce the concept of **variance** - Learn when to use **covariance or contravariance** - When to keep types **invariant** - Understand covariance or contravariance **positions** - When to use **Lower Bounds** #### Abstract Types - Introduce **Abstract Type Definitions** - Using Abstract Type Definitions to solve different problems - Using **Path Dependent types** - **Refinement types** and **Programmatic Structural types** - Appreciate **scala.Selectable** - **Caveats** of using Structural types - Using **Self-Types** - Using self-types for **dependency injection** (DI) - Discuss **DI alternatives** #### Context (Implicits) - Understand the concept of the **implicit context** - Understand the **rules** for brining in implicits into **scope** - Appreciate prioritizing of implicits - Define **low priority** implicits - **Best practices** for implicits - Define and use **implicit conversions** to convert between types - Enrich types using **extension methods** - Using **givens**/**using** to define **contextual parameters** #### Type classes - Understand the limitations of **subtype polymorphism** - Introduce the concept of **ad-hoc** polymorphism **Type classes** - What makes up a type class in Scala? - **Define** a type class - Provide **instances** using givens - Add **extension methods** - **Summoning** implicates in the current context - Using **Context Bounds** - Discuss use-cases and implement common type-classes (`Show`, `Functor`, …) - Understand and use the concept of **type-class derivation** - Provide and use the **derives** clause #### Opaque Type aliases - Recap **value types** - Understand the concepts of Opaque Type aliases - Defining opaque types - Expose ways to **lift** values to their internal type - Add methods to your new type ### Frequently asked questions Q: Do I need to know Scala 2 or Java first? A: No, you need experience in some programming language (a typed one helps), but the course teaches Scala 3 from first principles. Q: We maintain a Scala 2 codebase. Is this the right course? A: For Scala 2 teams we offer the Core Scala 2.x Masterclass, and for teams moving between the versions the dedicated Scala 3 upgrade course. Q: How is the course delivered? A: Live and instructor-led over 4 days, online or at your premises, in small interactive groups. --- ## Ansible Masterclass - Course code: ANSIBLE-CORE - URL: https://www.edc4it.com/training/course/ansible-training-masterclass - Duration: 3 days on-site, 4 days online - Categories: DevOps Training - Languages: English, French, Dutch ### About this course Learn to master Ansible, the powerful automation tool for modern infrastructure and application management. This modern course provides a comprehensive foundation in Ansible, including dynamic inventories, role development, automation testing, and centralized control with AWX. Perfect for system administrators, DevOps engineers, and IT professionals looking to simplify their workflows. What you will learn: Automate tasks with Ansible playbooks, modules, and roles. Use Ansible for provisioning, application configuration, CI/CD pipelines, GitOps, and provisioning VMs/Kubernetes. Explore advanced concepts like Jinja templating, plugins, and execution environments. Manage secrets securely with Ansible Vault, HashiCorp Vault, and Mozilla SOPS. Configure dynamic inventories for cloud providers, Kubernetes, and other systems. Use Molecule for testing. Integrate Ansible into modern DevOps workflows with AWX ### Who should attend System administrators, DevOps engineers and IT professionals who want to automate provisioning, configuration and application management, from single servers to cloud and Kubernetes estates. ### Prerequisites Students should have a basic understanding of linux system concepts. Some basic knowledge of Cloud, Docker, VMS and kubernetes is helpful, but not a requirement. ### What you will learn - Automate infrastructure tasks with playbooks, modules and roles - Template configurations with Jinja and structure complex playbooks - Configure dynamic inventories for cloud providers and Kubernetes - Manage secrets securely with Ansible Vault, HashiCorp Vault and Mozilla SOPS - Test automation with Molecule and troubleshoot plays effectively - Centralise automation with AWX / Ansible Automation Controller ### Outline ### Ansible Introduction - Introduce the **Ansible project** and its role in modern automation. - Discuss Ansible's role in **DevOps** and **GitOps** workflows. - Overview of Ansible's **History** - Understand the **use cases** for Ansible in infrastructure and application management. - Understand Ansible's **idempotent** behaviour - Ansible nodes (**control nodes** and **managed nodes**.) - Understand Ansible's **agentless** design. - Discover Ansible's **ecosystem**, including **Ansible Galaxy** and **AWX**. - Ansible **requirements** and **installation** ### Concepts #### Introduction - Introduce **tasks** - Understand **modules** and their purpose - Explore **collections** as a way to bundle ansible building blocks - Overview of key **modules** used in common scenarios. - Execute **ad-hoc commands** to perform quick actions on managed nodes. #### Inventories - Understand the purpose and structure of **inventories**. - Learn how to define **inventories** - Organise the inventory with host **groups** - Understand the role of **default groups** in inventories. - Compare **static** and **dynamic** inventories for managing nodes. - Use **inventory patterns** for targeting groups or hosts. - Define **host** and **group variables** in inventories. - Use **inventory variables** to customise host behaviour. #### Running Ansible (Ad-hoc) - Understand how tasks are **executed remotely** over SSH or WinRM. - Learn Ansible **configuration** options via *ansible.cfg*, env variables, and CLI parameters. - Identify key **configuration parameters** and their impact. - Understand the purpose of **variables** and **facts** in automation. - Learn about variable **scopes** (global, play, and host) and their precedence. - Use **local facts** to customise automation based on host-specific data. - Understand **facts gathering** and how to control or disable it. - Access **host** and **group variables** - Introduce **magic variables** and their special uses. - Overview of **jinja** templating for dynamic content in playbooks. #### Ansible Playbooks Basics - Introduce **playbooks** as the foundation of automation workflows. - Ansible's **YAML Conventions** - Understand the relationship between **plays** and **playbooks**. - Defining **multiple plays** in a playbook - Explore the **anatomy** of a play, including hosts, tasks, and variables. - Configure **hosts** and **execution behaviour** for a play. - Define and organise **tasks** within a playbook. - Identity and privilege **escalation** - Using **external** variable files - **Prompting** for values and passwords - Setting **facts values** - Introduce **handlers**, their purpose, and how they are triggered. - Introduction to **templating** with Jinja2. - Ensure playbook quality using **ansible-lint** and **yamllint**. ### Troubleshooting Plays - **Verify** playbooks using check mode and dry run options. - Investigate **modifications** using diffs. - **Step through tasks** for detailed analysis. - Use the **debug** module to display variables and custom messages. - Enable and use the **Debugger** for interactive troubleshooting. - Set **breakpoints** to pause execution and analyse issues. - **Inspect variables** and facts during execution. - **Change tasks** dynamically in debug mode. - Analyse **logs** and adjust **log levels** for deeper insights. - **Retry tasks** to address transient issues. ### Modules #### Core - Run **commands** and scripts. - Manage **files and directories**. - Copy **files and directories** with or without templating. - Install **software packages** (e.g., apt, yum, pip, gems). - Manage **users**, **groups**, and **passwords**. - Control **services** (start, stop, enable, disable). - Modify **file contents** (lines, blocks, configurations). - Automate **cron jobs** and scheduled tasks. - Debug with the **debug module**. - Configure **networking** (firewalls, routes, interfaces). - Manage **system performance** (resource limits, sysctl). #### Integrations - Manage **cloud resources** with dedicated modules (e.g., AWS, Azure, GCP, Hetzner). - Use **URI modules** for API integrations. - Configure **LDAP** for directory services and authentication. - Automate **SSL/TLS certificates**. - Send notifications with **Slack**, **email**, and other tools. - Manage **databases** (e.g., PostgreSQL). - Automate **network devices** (e.g., routers, switches, firewalls). - Configure **monitoring and alerting** systems (e.g., Prometheus, Grafana). #### Docker, Kubernetes, and GitOps - Handle **docker** resources in containerized environments. - Manage **container orchestration** with Kubernetes, including pods, services, and deployments. - Work with **container registries**, including pushing, pulling, and scanning images (e.g., Docker Hub, ECR, GCR, Nexus). - Introduction to configure **Kubernetes** clusters. - Automate **Helm chart deployments** and configuration in Kubernetes. - Automate **CI/CD pipelines** for containerized applications with GitOps principles. - Apply **rolling updates** and **rollback strategies** in Kubernetes deployments. ### Complex playbooks #### Templating with Jinja - Learn **jinja syntax** for templates. - Understand jinja's **role** in Ansible automation. - Use **expressions** and **filters** to transform data. - Apply jinja **tests** for conditional logic. - Write jinja statements (**for**, **if**, etc.). - Use **macros** and **custom filters** for reusable templates. - Understand **lookup** and key plugins for external data. - Combine lookup plugins with **loops** and **conditionals**. - Handle **whitespace** in jinja templates. - Work with **nested data structures** (e.g., dictionaries, lists) in templates. - Use the **ansible.builtin.vars** lookup plugin for advanced variable handling. - Manage **complex JSON and YAML transformations** with jinja filters. - Explore **community-contributed filters and plugins** for advanced use cases. #### Include and Import - Discuss **directory structures** for organising playbooks and roles. - Use **import** and **include** for tasks, playbooks, and roles. - Differentiate between **static imports** and **dynamic includes**. - Apply **conditionals** and **loops** with includes. - Explore **use cases** for reusability and modularization. - Pass **variables** to imports and includes. #### Playbook structures - Using ansible **loops** - Contrast loops with the deprecated **with_xxx** - Understand the relation between **loops, lookup, query and plugins** - Looping over **multiple tasks** using `include` - **Conditional** tasks using **when** - Implement **error handling** (e.g, `ignore_errors`, `failed_when`) - Group tasks into **blocks** for better structure and error control. - Use `try` and `finally` blocks for cleanup tasks and guaranteed execution. - List different run strategies (**linear**, **free** and **serial**) - Using **batch** for **rolling updates** - Delegate tasks with **delegate_to** and `local_action`. - Use **tags** to include/exclude tasks #### Plugins - Use **cache plugins** to optimise performance. - Configure **callback plugins** for managing output (e.g., logback, JSON, syslog). - Use **callback plugins** to interact with external systems (e.g., Slack, email). - **Audit** environments using callback plugins. - Configure different **connection types** (e.g., SSH, WinRM, local, docker). - Manage **Windows hosts** with WinRM and PowerShell. - Execute tasks inside **docker** containers with connection plugins. - Interact with **Kubernetes pods** and manage workloads. - Extend Ansible with custom **action, lookup, and filter plugins**. #### Dynamic inventories - Appreciate the need for **dynamic inventories** - Explore the transition from inventory **scripts** to inventory **plugins**. - List and discuss common inventory **plugins** (e.g., **AWS**, **Azure**, **GCP**, **Kubernetes**, **VMware**, **Docker**, **OpenStack**). - Configure inventory plugins using **YAML-based configuration** files. - Introduce the **ansible-inventory command** . - Using **caching mechanisms** to improve performance. - Overview of developing **custom** inventories scripts #### Managing Secrets and Sensitive Information - Discuss best practices for **storing and accessing secrets** in automation workflows. - Use **Ansible Vaults** to encrypt sensitive data. - Create and update **vaults** for secure storage. - Use **vaults** in playbooks to use secrets. - Use **Mozilla SOPS** for managing sensitive information - Integrate with **HashiCorp Vault**/**OpenBao****HashiCorp Vault** and other secret management systems. - Manage secrets with **Mozilla SOPS** ### Ansible Roles & Galaxy #### Introduction - Understand **the need for roles** to organise and reuse automation code. - Explore modern role **structure** and best practices. - Configure the **path to roles** with `ANSIBLE_ROLES_PATH` and other mechanisms. - Use roles with in playbooks. - Pass **variables** to roles and manage defaults. #### Galaxy - Introduce **Ansible Galaxy** as a hub for reusable roles and collections. - Use roles and collections from Galaxy in playbooks. - Manage Galaxy content with the **ansible-galaxy CLI** (e.g., install, init, search). #### Role Development - Write and structure custom **roles** following best practices. - Define role **meta-data**, including **dependencies** and versioning. - Publish custom roles to Galaxy or private repositories. #### Molecule - Introduce **Molecule** for testing and developing Ansible roles. - List and configure **drivers** (e.g., Docker, VirtualBox, EC2). - Define and configure **instances** for testing environments. - Understand and use **scenarios** to test different configurations and workflows. - Explore key **phases**: create, prepare, converge, verify, and cleanup. - Test for **idempotency** to ensure consistent results on repeated runs. - Write and run **verifications** to validate role behaviour. - Configure **platforms** and provisioners for Docker, Vagrant, or cloud VMs. - Use Molecule in a **DevOps pipeline** for automated testing. ### AWX / Ansible Automation Controller / Ansible Tower Overview - Introduce **Ansible Tower** - Understand the **benefits** of using Tower - Introduce the upstream **AWX project** and its relationship with Automation Controller/Tower. - **Installing** AWX - Manage **access control** with users, teams, and RBAC (role-based access control). - Define **inventories** in Tower/AWX - Supply secrets using **credentials** (e.g., environment variables, HashiCorp Vault). - Define **projects** linked to SCM systems (e.g., Git). - Create and use **job templates** for standardized workflows. - Running and monitoring **jobs** - Schedule jobs using the built-in **scheduler**. - Create and manage custom **Execution Environments** for isolated task execution. - Use **webhooks** (e.g., GitHub, GitLab) to trigger jobs automatically. - Extra: Explore **analytics** and **reporting** capabilities. ### Frequently asked questions Q: What do I need to know before attending? A: A basic understanding of Linux system concepts. Knowledge of cloud, Docker, VMs or Kubernetes helps but is not required. Q: Does the course cover AWX / Ansible Tower? A: Yes, the course closes with AWX / Ansible Automation Controller (Tower) for centralised, auditable automation. Q: How long is the course? A: 3 days onsite or 4 days online, live and instructor-led, in English, French or Dutch. --- ## Docker/OCI Container for Kubernetes - Course code: DOCKER-4K8S - URL: https://www.edc4it.com/training/course/DOCKER-4K8S - Duration: 2 days - Categories: Kubernetes Training, DevOps Training - Languages: English, French, Dutch ### About this course Master container technologies like Docker, Podman, and CRI-O within the context of Kubernetes clusters. This course focuses on Kubernetes-specific implementations, omitting standalone features like networking, persistence, and resource/health management found in traditional Docker/Podman environments. Perfect for those using containers in Kubernetes. ### Prerequisites Students should be familiar with general principles of software development. Some basic knowledge of software systems such as databases, web servers, etc is also required. Not a requirement, but having basic linux operating skills is very helpful. No prior knowledge of docker is required. ### Outline Note: This masterclass is tailored for individuals leveraging container technologies specifically within Kubernetes. If you're seeking a comprehensive Docker/Podman course, we recommend our [DOCKER-CORE](./DOCKER-CORE) offering. There, you'll dive into essential features for running Docker/Podman independently, including networking, persistence, resource/health management, Compose, and Podman pods. This comprehensive masterclass covers all the essential fundamentals while also going beyond the basics to explore the underlying technologies that power containerization, including Linux namespaces, overlay2 filesystems, and the runtime engines like crun/runc. This deep technical approach not only helps students develop a thorough understanding of container technologies at the system level, but also equips them with advanced troubleshooting techniques that aren't typically covered by standard container courses or exposed by the container technologies themselves. Students will gain insights into the low-level mechanisms ### Introduction - Introduction to **Containers** - Docker **history** - overview of **Podman** - OCI Container technologies (**Docker**, **Moby**,**Podman**, **Buildah**) - Discuss **runc/crun** in Podman/Docker/Containerd, - What **problems** do containers **solve** - **Benefits** of using containers - Introduce the Open Container Initiative (**OCI**) - Understand container **isolation** - Containers vs **virtual machines** - How containers facilitates **devops** - **Installing** Docker CE or Podman ### Containers - Deeper dive into container **isolation** - Introduce **Images** and the relation with containers - **Linux Namespaces** (PID, UTS, NET, etc) and containers - Understand **ephemeral** containers - Discuss the **various states** of a container (Created, Up, Paused, …) - **Running** and **Stopping** containers - Run **detached** containers in the background - **Managing** containers (listing, removing, inspecting, killing, pausing, restarting) - Discuss **go-templates** for inspecting containers - **Interactive** containers - **Executing** commands in running containers - **Copying files** and **directories** to and from containers - How to **Expose** (and **map**) network **ports** - **user** management and **permissions** - running containers as **non-root** - adding and dropping **Linux Capabilities** - Introduce use of **linux namespaces** (e.g, user namespaces in podman) - **Troubleshooting** containers - getting **information** (logs, exit codes, oom kill, …) - **debugging** containers - using **namespaces** to **troubleshoot containers** - Discuss benefits of **transient mode** (podman) - Using **systemd** #### Container Images (OCI) - Introduce Container **repositories** (Docker Hub, Quay.io) - Appreciate that images are **immutable** - Understand the Linux **overlay2 filesystem** and how it is used by containers and images. - **Managing** images (listing, removing, inspecting) - Fully understand **image layers** (including intermediate) - List different ways to **create images** - Container images **FROM scratch** - Creating **base images** (e.g., Debian) - Building an image **from Containers** - Using **Multi-stage builds** #### Creating and Using Container Files - Building images using different tools (docker, buildkit, buildah) - Understand the **syntax** of a `Containerfile`/`Dockerfile` - Choosing and specifying a **base image** - Adding **meta-data** - Understand the **build process** - Understand the build **context** - Introduce **dockerignore** files - How to optimise **reusing** of layers - **Running** commands effectively - Understand **shell-form** and **exec-form** when running commands - Keeping your builds **deterministic** - Copying **files** and **directories** - improve performance using **COPY --link** - Difference between **COPY and ADD** - Understand the **working directory** (and changing it) - Defining network **ports** - Changing the container's **environment** - Building **executable** containers - Understand how to use **ENTRYPOINT** and/or **CMD** - Writing **entrypoint scripts** (e.g, `entrypoint.sh`) and replacing **PID 1** - **Best practices** in creating images - Using traditional **build containers** - Using **multi-stage build** files - using **mounts** in dockerfiles (e.g., **secrets**, **ssh*, …) - speed-up builds using **cache mounts** --- ## Docker/Podman/OCI Container Masterclass - Course code: DOCKER-CORE - URL: https://www.edc4it.com/training/course/docker-podman-container-training - Duration: 3 days - Categories: Kubernetes Training, DevOps Training - Languages: English, French, Dutch ### About this course A hands-on 3-day Docker and Podman masterclass: containers, images, Dockerfiles, volumes, networking, Compose and pods. No prior Docker knowledge required. For companies with their sights set firmly on the future, container technologies such as Docker and Podman are the next step their teams need to take. With a solid grasp of the benefits containers have to offer, your department will be at the forefront, delivering outstanding efficiency and smooth, reliable performance. Book a course with us and your team will be led each step of the way by one of our experienced and highly skilled instructors. They will be on hand to answer any queries your team has, and this level of attention applies whether your team gets to grips with containers through an online course or an onsite experience. During the course, students can use either docker or podman. ### Who should attend Developers, system administrators and DevOps engineers adopting container technology, as well as teams that already use containers but want to understand what happens beneath the abstraction. ### Prerequisites Students should be familiar with general principles of software development. Some basic knowledge of software systems such as databases, web servers, etc is also required. Not a requirement, but having basic linux operating skills is very helpful. No prior knowledge of docker is required. ### What you will learn - Run and manage containers confidently with Docker or Podman - Build efficient, secure container images with Dockerfiles/Containerfiles - Persist data with volumes and connect containers with container networking - Compose multi-container applications with Docker Compose - Work with pods in Podman as a stepping stone towards Kubernetes - Understand the underlying OCI, image and runtime technology, not just the commands ### Outline This comprehensive masterclass covers the essential fundamentals of containerization and goes beyond the basics to explore the underlying technologies that power it. Guided by our teaching philosophy: that understanding an abstraction requires knowledge of the layer directly beneath it, we dive into the core Linux technologies that make containers possible. We explore Linux namespaces, Linux Signals, cgroups, Linux technologies used in container network stacks, overlay2 filesystems, and the runtime engines like crun/runc. This deep technical approach not only helps students develop a thorough understanding of container technologies at the system level, but also equips them with advanced troubleshooting techniques that aren't typically covered by standard container courses or exposed by the container technologies like Docker/Podman themselves. Students will gain insights into the low-level mechanisms that make containerization possible, enabling them to diagnose and resolve complex issues in production environments. ### Introduction - Introduction to **Containers** - Docker **history** - overview of **Podman** - OCI Container technologies (**Docker**, **Moby**,**Podman**, …) - Brief discussion of **Windows Native Containers** - Discuss **runc/crun** in Podman/Docker/Containerd, - What **problems** do containers **solve** - **Benefits** of using containers - Introduce the Open Container Initiative (**OCI**) - Understand container **isolation** - How containers facilitates **devops** - Containers vs **virtual machines** - Linux Containers (**LXC**/**LXD**/…) vs Application/OCI Containers - Introduce **Linux Namespaces** ### Containers - Deeper dive into container **isolation** - Introduce **Images** and the relation with containers - **Linux Namespaces** (PID, UTS, NET, etc) and containers - Understand **ephemeral** containers - Discuss the **various states** of a container (Created, Up, Paused, …) - **Running** and **Stopping** containers - Run **detached** containers in the background - **Managing** containers (listing, removing, inspecting, killing, pausing, restarting) - Understanding **Signals** on Linux - Understand the quirks of PID 1 on Linux and how to avoid them using **init containers** (catatonit/tiny/…) - Discuss **go-templates** for inspecting containers - **Interactive** containers - **Executing** commands in running containers - **Copying files** and **directories** to and from containers - How to **Expose** (and **map**) network **ports** - **user** management and **permissions** - running containers as **non-root** - adding and dropping **Linux Capabilities** - Introduce use of **linux namespaces** (e.g, user namespaces in podman) - **Troubleshooting** containers - Introduce the **OCI Runtime Bundle** - getting **information** (logs, exit codes, oom kill, …) - **debugging** containers - using **namespaces** to **troubleshoot containers** (pid/network/mount/user) - Discuss benefits of **transient mode** (podman) - Using **systemd** - Use Podman **Quadlets** to ease systemd integration #### Container Images (OCI & Docker v2) - Introduce Container **repositories** (Docker Hub, Quay.io) - Appreciate that images are **immutable** - Understand the Linux **overlay2 filesystem** and how it is used by containers and images. - Understand **OCI Image Format** (and how it differs from Docker v2) - **Managing** images (listing, removing, inspecting) - Fully understand **image layers** (including intermediate) - List different ways to **create images** - Container images **FROM scratch** - Creating **base images** (e.g., Debian) - Building an image **from Containers** - Using **Multi-stage builds** #### Creating and Using Dockerfile/Container files - Building images using different tools (docker, buildkit, buildah) - Understand the **syntax** of a `Containerfile`/`Dockerfile` - Choosing and specifying a **base image** - Adding **meta-data** - Understand the **build process** - Use docker **BuildKit instances** (e.g, k8s, remote, docker-container) - Understand and leverage different **build caches** - Understand the build **context** - Introduce **dockerignore** files - How to optimise **reusing** of layers - **Running** commands effectively - Using **linters** to check your Dockerfile (and shell scripts) - Understand **shell-form** and **exec-form** when running commands - Keeping your builds **deterministic** - Copying **files** and **directories** - Using **--filter** to filter copied files - improve performance using **--link** - Difference between **COPY and ADD** - Understand the **working directory** (and changing it) - Defining network **ports** - Changing the container's **environment** - Building **executable** containers - Understand how to use **ENTRYPOINT** and/or **CMD** - Appreciate the **exec form** (and its relation to the `execve` syscall) - Writing **entrypoint scripts** (e.g, `entrypoint.sh`) and replacing **PID 1** - **Best practices** in creating images - Using traditional **build containers** - Using **multi-stage build** files - using **mounts** in dockerfiles (e.g., **secrets**, **ssh*, …) - speed-up builds using **cache mounts** - Using **sharable build caches** (s3, registry, azure blobs, …) #### Volumes - Understand the need for data volumes - Introduce the volume **architecture** - Creating and inspecting **volumes** - **Sharing** data - Using the **volume CLI** - Use **mount binding** - Binding to the **local file-system** - Binding to **named volumes** - Mounting **tmpfs** - Using *legacy* **Volume Containers** - managing **file permissions** in docker (e.g, **posix ACL**) - Mounting **options** (read-only, selinux labels, …) - Using different **mount types** (e.g, nfs, cephfs, fuse, …) - Working with **Podman Secrets** - Using Podman **unshare** and the **mount** namespace #### Networking - Understand container's **networking architecture** - List different network types (**bridge**, **host**, **none**, **overlay**, **nspath**, and **macvlan**/**ipvlan**) - Understand rootless networking in Podman (**pasta**/**slirp4ns**) - Understand how rootless networking (using **rootless networking namespaces**) - understand how bridge, **vnet** and **tap** networks are used in Podman - Introduce the **Network CLI** - **Managing** networks (listing, inspecting, …) - Understand the **problems** of the default bridge network - Discuss and use the **deprecated container links** - Creating a **custom bridge networks** - Creating **macvlan** and **ipvlan** networks - **Connecting containers** to a network - Connecting to **multiple networks** - Use of **DNS** inside a custom network - Managing the **upstream DNS** configuration - Introduce **aardvark-dns** in Podman - **Registering** additional **domain names** for a container - Managing container's **/etc/hosts** #### Container Management - Container **restart policies** - Constrain container's **memory** - Constrain container's **CPU resources** - Set up a **self-hosted** repository - Understand the relation between **image names** and **repository** - **Pulling and Pushing** images - Understand container **logging** - Log **configuration** - Using different **logging drivers** - Setup **fluentd/elasticsearch** with **kibana** - Setup **cAdvisor** and **Prometheus** #### Docker Compose - Introduce **docker-compose** - Using **podman** with Compose - introduction to the **yaml** syntax - Writing **compose yaml** files - configuring **containers** inside compose - Understand **networks** in Compose - Setting up **dependencies** between services - configuring **volumes** inside compose - using **configs** and **secrets** - configuring runtime **deploy** options (resources, restart policies, etc) - Use **profiles** to activate services per environment - **merging** compose files - **including** and **extending** compose files ### Pods (Podman) - Introduce kubernetes **Pod** objects - Explore **imperative** pod definitions - Appreciate **declarative** yaml definitions - Add **containers** to pods - Understand **volume and mounts** in pods - Introduce **ConfigMap** for application configuration - Map configmap data to **environment variables and volume mounts** - Use **kubernetes Secrets** for Podman Secrets ### Frequently asked questions Q: Do we use Docker or Podman? A: Either: the course covers both, and every student can choose the tooling that matches their environment. The concepts (OCI images, containers, registries) are identical. Q: Do I need Docker experience to attend? A: No. You should be comfortable with general software development concepts, and basic Linux skills help, but no prior container knowledge is required. Q: What is the next step after this course? A: Most teams continue to Kubernetes with our Core Kubernetes Masterclass (or the compact DOCKER-4K8S route if you only need the container foundation for it). Q: How is the course delivered? A: Live and instructor-led, online or at your premises, in English, French or Dutch, in small groups (max 10 onsite, 7 online). --- ## Core Go (Golang) - Course code: GOLANG-CORE - URL: https://www.edc4it.com/training/course/GOLANG-CORE - Duration: 3 days - Categories: Programming Language Courses - Languages: English ### About this course This is a modern, instructor-led, and highly interactive Go programming language course designed to teach you how to read, write and understand Go code. The course teaches you the fundamentals and advanced features of Go. Some of the core concepts that we cover include concurrency, modules, generics, and standard libraries (IO, HTTP, etc), among others. The course is designed assuming students have no prior knowledge of Go. ### Prerequisites Students should be familiar with other programming languages such as C, Java, C#, C++, Rust, Javascript/Typescript, Python, etc. Having knowledge of a typed language is an added advantage. ### Outline ### Introduction to Go - **history** of the go Language - language **philosophy** - Understand the go development **environment** - understand **GOPATH** (and **GOROOT**) - overview of go **tools** - Popular **3rd party tools** - setting up a **go module** - **building** and running go modules - Overview of **GNU Make** for go developers - Writing makefiles ### Language Basics - introduce the **language structure** (statements, declarations, expressions) - Declaring and using **identifiers** - List various ways of **declaring variables** - Introduction to **types** and their **literals** - Appreciate type **inference** - Use primitive types (strings, integers, floating point, booleans, …) - Using **type conversion** - use **constant declarations** - using **list expressions** for variables and constants - Understand and use **iota** - using **assignment** and **incdec** statements - understand special types **any**, **nil** and **error** - introduce **panic** #### Arrays & Slices - understand arrays in go - declaring **array types** - use the **composite literal syntax** for array literals - accessing elements using **index expressions** - **caveats** using arrays - introduce **slices** - understand the relation between arrays and slices - construct **slice literals** and **slice expressions** - **looping** through arrays - using builtin **slice functions** (`append`, `copy`, …) #### Strings and Runes - understand strings, utf-8 and byte slices - understand the different **string literals** (e.g., interpreted vs raw) - string **operations and functions** (concatenation, substrings, split, join etc.) - introduce the **rune** type - use the **utf8 package** #### Maps - introduce the **map** type - understand **hash-map** implementations - constructing maps using **map literals** - introduce go's **comma ok pattern** - **crud** on map elements #### Structs - introduce structs as a **product type** - defining **fields** - explore various ways of supplying **values** - using **anonymous structs** - **embedding** fields for **composition** - introduce struct **tags** and explore use cases ### Control Structures - recap the role of **statements** - **block statements** and **scoping** rules - using **if-statements** - adding **simple statements** to other statements (e.g., initialise scoped variables) - introduce many forms of **for-statements** - using **c-style** for-loops - writing **while** loops (and how to create **do-loops**) - using **for-each** for ranges - using **break** and **continue** - introduce **switch-statements** - using **fallthrough** ### Functions - introduce function characteristics (and difference from other languages) - understand go **always by value** parameters - **declaring** and **calling** functions - **returning** one or more values - using **named** return values - declaring and calling **variadic parameters** - using structs for **named-parameters** - functions as **1st class values** - discuss use cases for **higher-order** functions - introduce and declare **function types** - use **function literals** (aka lambda expressions) - introduce and use **clojures** #### Go's Error handling - introduce **errors as values** (and differences with other languages) - introduce the **error type** - **handling** errors - explicitly **ignoring** errors - discuss various ways of **creating errors** - appreciate **wrapped messages** - managing errors and (lack of) **stacktraces** - discuss **panic** and their difference with errors - **raising** explicitly #### Defer statements - understand the **semantics** of defer-statements - discuss **use-cases** for defer-statements - using defer for **ARM** - declaring **multiple** defer-statements - **handling** panics using defer ### Pointers - introduce the **concept** of pointers - list addressable types/values - using the **address-operator** - dereference pointers using **indirect-operator** - declaring **pointer-types** - briefly discuss the **unsafe package** - discuss and use pointers as **function parameters** and **return** values ### Methods & Interfaces - how go is and isn't an **object-oriented** languages - define the concept of **methods** - **declaring** methods on structs - discuss **receiver** pointer vs value - methods **as values** - adding methods to **other types** (including built-in types) #### Interfaces - introduce interfaces and **duck typing** - **declaring** and **"implementing"** interfaces - **idiomatic** use of interfaces in go - understand the use for **empty interface** (and its alias `any`) - using **functions** to implement interfaces (aka "single abstract method") - introduce the **type adaptor** pattern - introduce **embedded interfaces** - using **type assertions** - use the **type switch** for type-based pattern matching ### Generics - introduce the concept of **generics** (as type constructors) - discuss the scope and **limitations** of generics in go - Defining generic **functions** using **type declarations** - using embedded interfaces to declare type parameters - defining **generic types** - using generics with **methods** ### Concurrency - discuss the theory behind **concurrency** (and the relationship with **parallelism**) - introduce **Communicating Sequential Processes** (CSP) - introduce **goroutines** (and how they relate to threads and green threads) - discuss the concept of **channels** - understand **buffered** channels - **writing** goroutines and using channels for communication - protect against **resource leaks** - defining and initialising **channel types** - using channel operators: **send** and **receive** - using **for-range** statements - introduce the **select-statement** (and **for-select**) - discuss various concurrently pattern (generators, fan-in, fan-out, timeout, done/quit, once, pools) - use **wait groups** for synchronisation ### Context - introduce context for **scoped values** and **cancellation** - **passing** contexts around - understand context **trees** - defining the **root** context - adding and getting **values** to a context - introduce **cancellation** primitives - **explicitly** cancelling a context - using **time-out** (and deadlines) - implementing **cancelable** goroutine ### Modules - introduce go's **program structure** - set-up **modules** - understand the role of **module paths** - discuss different ways to **organise your files** - understand go **packages** - writing runnable **applications** (as apposed to **libraries**) - **export** identifiers and **importing** them - use **internal** packages ### IO and HTTP #### IO - introduce the **io package** - introduce **io.Reader** and **io.Writer** - list built-in **behavioural io** readers/writers - using the **decorator** pattern to chain behaviour - list common **sentinel errors** - using the **ioutil** package - reading/writing **files** - accessing the **stdin** and **stdout** #### http ##### server - define and **configure** a Server - understand the relation between the http and **net** packages - writing **handlers** - understand the **http model** (requests, responses, headers, etc) - leverage the **HandlerFunc type adapter** - using **ServeMux** to use url pattern matching - discuss **3rd party routers** - list and use **behavioural handlers*** (static file serving, redirection) - working with various **timout** configurations (read, write, idle, …) - properly implement **cancelable handlers** - understand the use of **context in http** - implement and use**middleware** (including 3rd party) ##### json - working with **JSON** - **marshalling/unmarshalling** json data - using **json tags** - implementing **custom codecs** (custom marshalling/unmarshalling) - improve performance using **encoders/decoders** (streaming io API) ##### client - define and **configure** an http Client - making **http requests** - handling the **response** body - **posting** data - handling **timeouts** --- ## Using Istio Service Mesh on k8s - Course code: ISTIO-K8S - URL: https://www.edc4it.com/training/course/istio-service-mesh-training - Duration: 2 days - Categories: Kubernetes Training, DevOps Training - Languages: English, French, Dutch ### About this course This course explains how to use the Istio ServiceMesh for routing and managing network traffic, enforce security and how to observe telemetry. ### Who should attend Teams running (or moving towards) a microservice architecture on Kubernetes who need traffic management, zero-trust security and observability without changing application code. ### Prerequisites Students are expected to have basic knowledge of Kubernetes. We advice students to follow our KUBERNETES course. Though not required, it is helpful to have an understanding of Microservice architecture and patterns ### What you will learn - Understand what a service mesh is and how the sidecar pattern works - Manage and route traffic, including canary-style rollouts - Secure service-to-service communication with mutual TLS and authorization policies - Observe your mesh with Istio's telemetry ### Outline ### Introduction - Introduction to a **Service Mesh** - Introduce/recap Micro-services Architecture (**MSA** ) patterns (in particular the **sidecar**) - Discuss challenges in a service mesh - Understand the differences between an **Enterprise Service Bus (ESB) and a Service Mesh** - Introduce Istio - High-level **architecture** of Istio - Components of the **data plane** and **control plane** - Introduce the **Envoy** project and its use in Istio - Brief overview of installation and configuration techniques (e.g., Istioctl, **Helm**) - Install Istio using **Istioctl** ### Traffic Management - Overview of traffic management with Istio - Controlling **Ingress** and **Egress** traffic - Configuring **Gateways** - Defining **Virtual Services** - Understand **host** and **destination** bindings - Controlling **HTTP** traffic (matching, rewriting, redirecting, …) - Testing resilience by using declarative **faults** - Using **Destination rules** - Flowing traffic to different versions (**subsets**) - Managing versions using **mirroring** - Explicitly adding **Service Entries** for outside traffic - Resilience service with **Circuit Breakers** ### Security - Understand the need for declarative security - List security tasks (*identity*, *message privacy*, *message integrity*, *non-repudiation*) - Understand Istio **identity** (users, services) - Add end-user authentication using JWT - Apply **Mutual TLS** (mTLS) for inter-service authentication - Managing certificates - mTLS Migration techniques - Using **namespaces** and label **selectors** to enforce policies - Define HTTP-based **access-control** - Using JWT to define end-user/external client access control ### Telemetry - Overview of Istio's **Observability** options - Using Envoy's **access logs** - Introduce **Metrics** - Understand the different levels of metrics gathering (Envoy, Service and control plane) - Configuring **service-level** metrics - Using **Prometheus** and **Grafana** for metric visualisation - Trace request traffic through your mesh (**Distributed traces**) - Using **Jaeger** as a trace-backend (discuss other options) ### Frequently asked questions Q: What do I need to know before attending? A: Basic Kubernetes knowledge is expected; our Core Kubernetes Masterclass is the recommended preparation. Familiarity with microservice patterns helps but is not required. Q: How is the course delivered? A: Live and instructor-led, online or at your premises, in English, French or Dutch, in small groups (max 10 onsite, 7 online). --- ## Core React Native - Course code: RN-CORE - URL: https://www.edc4it.com/training/course/RN-CORE - Duration: 2 days - Categories: Web Development Training - Languages: English ### About this course This is a fast-paced course to get you started building mobile applications for Android and iOS using React Native. ### Prerequisites Students should be familiar with ReactJS Programming as covered in our ReactJS Masterclass course. By default the labs and demos are using TypeScript. Though not required, experience with TypeScript can be helpful. ### Outline ### Introduction - Introduce React Native/s **Architecture** - Understand key inner workings - Discuss **Native Modules** and **View Managers** - Understand implications on **threading** - Setting up projects using **React Native CLI** - Understand the role of **Metro** - Setting up projects using **Expo** - Developing Using **Emulators/Simulators** and **real devices** - **Debugging** expo Applications (including **react native debugger**) ### Core Components - Understand the **relation** between React **components** and **native views** - Introduce **View** components - Understand **styling** in React Native (and the differences with **CSS**) - Appreciate and use the **flex-layout** - Building **responsive** UIs (Detecting and adapting to dimensions, orientation, device type/model etc.) - Best practices for working with **colours and themes** (including **dark** settings) - Working with **safe areas** - Working with **Images** (sources, resizing, caching, optimisation) - Adding and styling **Text** - Accepting touch gestures using **Touchable** components - Introduce the **Pressable** API - Using **scrollable** and **list** components (e.g., **FlatList**, **SectionList**) - Using list component features (separators, headers/footers, refreshing, infinite scroll, …) - Use and explore **other Core components** ### Animations - Understand the core **Animated architecture** - Using **native animations** - Using **animatable components** - Discuss **animation best practices** - Understand and configure different **types** of animations (e.g., timed, spring, …) - Use **easing** functions - **Composing** animations - Appreciate and apply **Interpolation** and **Extrapolation** - Using **Events** with animations ### Gestures - Discuss various **gestures types** (e.g, tap, pan, pinch) - Understand and use React Native **Gesture Responder System** - Introduce the **react-native-gesture-handler** library - Discuss the different **gesture handlers** - Using the **PanGestureHandler** - List and use various gesture components (e.g, **Swipeable**, **FlatList**, …) ### Navigation - Introduce the **react-navigation** library - Discuss and use various **navigation techniques** (stack, tabs, drawer, …) - Using react-navigation with **TypeScript** - **Nesting** navigators - **Configure** navigators and screens - Tune tab navigation **layout** (icons, headers, buttons, etc.) - Using the Imperative **navigation API** - Using **Params** ### Accessing back-end services - Recap using Axios and **Apisauce** to access **backends** - **Authentication** and **Authorisation** (using **JWT**) - **Offline authentication** ### Local Storage and caching - Changing application behaviour based on **network status** - Discuss **storage techniques** - Using the key-value **AsyncStorage** - Accessing the **file system** to store/cache files - **Downloading/uploading** files --- ## Scala 3 Upgrade Course - Course code: SCALA-UPGRADE-3 - URL: https://www.edc4it.com/training/course/SCALA-UPGRADE-3 - Duration: 1 day - Categories: Scala Training - Languages: English, French, Dutch ### About this course This is a great course that familiarises experienced scala developers with the new features that were introduced in Scala 3. The course also covers migration techniques and strategies. ### Prerequisites Students should be familiar with Scala 2 ### Outline We are proud to offer this Scala 3 *upgrade* course. This course is geared toward students that already are familiar with Scala 2 and wish to quickly learn new and updated language features, techniques and migration strategies. If you are a newcomer to scala, we recommend our Core Scala 3 course: [SCALA-CORE](./SCALA-CORE). EDC4IT has been working with Scala since the early 2000s, and has taught many teams. We worked together with different teams on their projects. This course covers: ### Introduction to Scala 3 - Introduce Scala 3 - Changes to the compiler (and intro into DOT calculus) - Optional braces and indentation - Deprecated features ### New Language Features - Explicit nulls and safe initialization - Intersection and union types - Using enums for simplified ADTs - Simplified pattern matching - Discuss changes in Macro support - Changes for traits (parameters, transient, …) - Using export clauses ### Changes - Changes to refinement and structural types - Changes for operators and infix notation - Defining applications (and using the FromString type-class) - Open/closed classes - Changes to eta-expansion - Changes to equality (and using type-class derivation) - Other changes ### Changes in Implicits - defining implicit conversions - Using extension methods - using givens/using - Defining and implementing Type Classes in Scala 3 - Opaque Type Aliases - Introduce Type-class derivation ### Migration Strategies - Discuss migration strategies - Manage dependencies and use scala 2 libraries - Using compiler flags - Using the compiler to aid in migration - Applying scalafix rules - Using sbt (Scala 3 Migrate Plugin) --- ## Modern JavaScript/ECMAScript Masterclass - Course code: ES-CORE - URL: https://www.edc4it.com/training/course/ES-CORE - Duration: 4 days - Categories: Web Development Training - Languages: English, French ### About this course Master JavaScript from the ground up with this comprehensive Core JavaScript course. Designed for developers looking to build a strong foundation, this course covers everything from basic syntax to advanced concepts like classes, functional programming, and asynchronous code. Dive deep into the essentials of browser-based JavaScript, including DOM manipulation, event handling, and modern ES features. This course also introduces testing practices and prepares you for frameworks like Angular, React, Vue, and Svelte. What you will learn: Understand modern JavaScript syntax, features, and best practices. Organize and structure your code effectively with modern ES Modules. Write robust object-oriented and functional JavaScript. Manage asynchronous workflows with promises and async/await. Manipulate and interact with the DOM using modern APIs. Leverage JavaScript modules for structured and maintainable code. Test JavaScript code with tools like Jest and Vite-Test. Prepare for advanced JavaScript concepts and frameworks. ### Prerequisites It is expected that delegates will be familiar with basic programming principles in languages such as Java, C#, Python or similar as well as show experience in HTML/CSS. ### Outline ### Core JavaScript/ECMAScript #### Introduction - Introduce **JavaScript** and its standard, **ECMAScript**. - Explore the evolution (**ECMAScript versions**, ES5, ES6/ES2015, and beyond). - Discuss **browser and runtime support** for modern ECMAScript features. - Explain language basics: **literals**, **identifiers**, **operators**, and **reserved words**. - Introduce the **JavaScript Type System** and its dynamic nature. - Highlight the differences between **primitive types** and **objects**. #### Node.js and Babel for front-end development - Introduce **Node.js** (for front-end development) - Setting up a new **project** - Understand `package.json` - Managing dependencies using **npm** and/or **yarn** - Introduce package registries (public and private) - Use linters such as **JSHint** - Introduce **Babel** - Setting up a babel project - Appreciate babel **plugins** and **presets** - Use and configure the **preset-env** - Introduce **Browserlist** - Defining browserlist **queries** to define your **target** (e.g, browsers) #### Core Syntax - Understand **equality** (`==` vs `===`). - Explain **falsy** and **truthy** values. - Appreciate **strict mode** - Declare variables with **let** and **const**, and the legacy **var**. - Discuss the benefits of **immutable values**. - Explore **global objects** in various environments. - Understand **type coercion** and its pitfalls. - Define and use **named functions**. - Introduce modern string literals with **template strings**. - Use different types of **expressions** (arithmetic, logical, etc.). - Apply **control structures** such as `if`, `for`, and `while`. - Discuss the **advantages of expressions** over statements. - Understand and use **exceptions** for error handling. - Using **tr/catch** to handle exceptions #### Modules and Code Organization - Understand **modules**. - Explore **ES Modules** (`import`/`export`) and their compatibility with older systems. - Compare **modules** with older patterns like **immediately invoked function expressions (IIFE)**. - Learn various `import` and `export` techniques (default, named, and re-exports). - Use **dynamic imports** for code splitting and lazy loading. - Organize large codebases with **barrel files** for cleaner imports. ### Objects, Classes and Object-oriented JavaScript #### Objects introduction - Create objects as **object literals**. - Define object **properties** and **methods**. - Use getters and setters **accessors**. - Apply **shorthand property names** for conciseness. - Use **destructuring assignments** for objects. - Leverage destructuring with **immutable objects**. - Define and use **constructors** to initialize objects. - Discuss limitations of constructors compared to **class syntax** (explained later). #### Core Objects and Utilities - Declare and manipulate **arrays**. - Use mutable array methods (**pop**, **push**, **(un)shift**, **slice**, **splice**, etc.). - Work with iterables using the **for...of** loop and **spread syntax**. - Work with core object types: **Date** and **String**. - Understand and use **Map** and **Set** for efficient data storage. - Explore **WeakMap** and **WeakSet** for memory-managed key-value pairs. - Work with the **Math** object for mathematical operations. - Introduce the **JSON** object for parsing and stringifying data. #### Dealing with Null and Undefined - Understand the **difference** between `null` and `undefined`. - Recognize the problems caused by **nullish values** (`null` and `undefined`). - **Protect** against nullish values using safe patterns. - Use logical operators (**&&**, **||**) for fallback logic. - Apply **optional chaining** (`?.`) to safely access nested properties (ES2020). - Use the **nullish coalescing operator** (`??`) to handle default values (ES2020). - Combine **optional chaining** and **nullish coalescing** for safer expressions. - Explore **default destructuring** to provide fallback values when destructuring objects or arrays. ### Classes - Explain **prototypical inheritance**. - Define and use **ES classes**. - Add **methods** to classes to add behaviors. - Define and use **constructor functions** to initialize objects. - **Override** methods and constructors. - Define **fields**, including **private fields** (ES2020+). - Add **static members** to classes for shared properties or methods. - Implement **class inheritance** with the `extends` keyword. - Discuss the differences between **class syntax** and traditional prototypes. ### Functions #### More on Functions - Use **default parameters** to assign fallback values. - Apply **rest/variadic parameters**. - Use **destructured parameters** to improve readability. - Combine **default values** with destructured parameters for cleaner function signatures. - Explore the **arguments** object and its limitations in modern JavaScript. - Understand **function scope** and the role of the **this** keyword. #### Functional JavaScript - Understand the principles of **Functional Programming**. - Explore Functional Programming in **JavaScript**. - Deal with **state** and avoid **mutability**. - Use **functions as values** for dynamic programming. - Write and use **higher-order functions** to pass and return functions. - Using **clojures** - Define **lambda expressions** for inline function behavior. - Use **arrow functions** and understand their differences from traditional functions. - Discuss the importance of **pure functions** and avoiding side effects. - Combine functions using the **pipeline operator** (`|>`) for cleaner composition - Implement **currying** to break down functions into smaller, single-argument functions. - Use **recursion** to solve iterative problems in a functional style. - Introduce popular **functional libraries** #### Functional Style Arrays and Iterables - Recap **arrays** and their role as iterables in JavaScript. - Use array **higher-order functions** for clean and functional operations. - Transform arrays using **map** as a functor. - **Filter** arrays to extract elements based on conditions. - Apply **predicate logic** to arrays for testing values. - Find elements in arrays using **find** and **findIndex**. - Combine array methods (**map**, **filter**, **reduce**). ### Asynchronous Programming - Use **Promise** for handling asynchronous code. - Define and manage **promises**. - Handle promise **errors** with `.catch` and `finally`. - Combine multiple promises with **Promise.all/any/race**. - Use **async/await** for cleaner asynchronous code. - Handle errors in **async/await** with `try/catch`. ### Testing / BDD - Introduce the importance of **testing** in software development. - Discuss different testing techniques (**unit, BDD, e2e**). - Introduce and use modern tools like **Jest** and **Vite-Test**. - Write **Suites** and **Specs** for structured test cases. - Test **asynchronous code** effectively. - Use **Mocking** and **Stubbing** with tools like **Spies**. - Mock **time** for testing time-sensitive code. ### JavaScript in the Browser #### Introduction - Add JavaScript to pages: **unobtrusive**, **inline**, and **external** scripts. - Explore ways of loading external scripts: **async** and **defer** attributes. #### JavaScript Modules in the Browser - Introduce **ES Modules** (`