Grootste online IT opleider

Beste klantenservice

Award winning e-learning

Na betaling, direct starten

Training: Certified Kubernetes Administrator (CKA)

€ 389,00
€ 470,69 Incl. BTW
Bestellen namens een bedrijf?

Duur: 32 uur |

Taal: Engels (US) |

Online toegang: 180 dagen |

In Onbeperkt Leren

Gegevens

De naam Kubernetes is Grieks voor stuurman of piloot. Kubernetes host als het ware jouw containers met applicaties op haar schip. Kubernetes is namelijk een platform waarop je containers op grote schaal kunt draaien in de cloud. In Kubernetes heb je ook het overzicht over al deze containers. Kubernetes is opensource-organisatiesoftware waarmee je containers kunt implementeren, beheren en schalen. Wil jij meer leren over Kubernetes en jezelf ontwikkelen tot Certified Kubernetes Administrator (CKA)? Dan is deze training iets voor jou! De training richt zich op het op niveau brengen van kennis en vaardigheden die gevraagd worden om het CKA examen succesvol te kunnen volbrengen.

In deze training ga je kijken naar de verschillende toepassingen van Kubernetes. Je gaat aan de slag met de uitdagingen die transformatie van een monolith applicatie naar microservices met zich meebrengen. Je gaat kijken welke rol Kubernetes hierin kan spelen. Om een beter beeld te krijgen van deze rol, is het belangrijk om inzicht te hebben in de verschillende onderdelen en features van Kubernetes. Hoe kan je deze installeren en wat zijn de key criteria om Kubernetes oplossingen te evalueren?

Onderwerpen die in deze training aan bod komen zijn:

  • Cluster Installation & Configuration
  • Managing Role-based Access Control and Highly-available Clusters
  • Managing Kubernetes Deployments
  • Configuring ConfigMaps & Kubernetes Secrets
  • Managing Pods & Deployments
  • Configuring Networking & Services
  • Ingress and Cluster DNS & CNI Management
  • Managing StorageClass & Volume
  • The Logging Mechanism
  • Auditing & Customizing Logs
  • Monitoring Kubernetes Metrics
  • Troubleshooting Cluster Components, Deployments & Networking, Cloud-hosted Kubernetes
  • ''All-in-one'' Kubernetes installeren die gebruik maakt van containers om Kubernetes componenten.

En nog veel meer!

Resultaat

Na het volgen van deze training heb je meer inzicht over de rol, werking en toepassingsmogelijkheden van Kubernetes. Daarnaast ben je voorbereidt op het Certified Kubernetes Administrator (CKA) examen.

Voorkennis

Wij adviseren een redelijk goed begrip van de essentiële Linux command line, evenals Linux-netwerken en servicebeheer.

Doelgroep

Systeembeheerder, Netwerkbeheerder, Securityspecialist

Inhoud

Certified Kubernetes Administrator (CKA)

32 uur

Kubernetes Administrator: Kubernetes Fundamentals for Administrators

  • Migrating from monolith to stable microservices architectures require robust, scalable, and containerized deployment and orchestration capabilities.
  • In this course, you'll explore the challenges of transforming from monolith applications to microservices, the benefits of microservices and container orchestration, and various container orchestration deployment options for managing containerized deployments.
  • You'll investigate the evolution, key features, and components of Kubernetes, identifying the pros and cons of the recommended installation and configuration options for Kubernetes and establishing the key criteria for evaluating Kubernetes solutions for enterprise workloads, including using Pods to manage multiple containers.
  • Additionally, you'll install "all-in-one" Kubernetes using containers to run Kubernetes components as Docker containers on a single host. You'll use kubectl to run applications on Kubernetes clusters. Lastly, you'll create a service that targets TCP port 80 on any Pod and expose this service onto an external IP address.

Kubernetes Administrator: Cluster Installation & Configuration

  • Kubernetes provides various tools specifically designed to run

  • enterprise-class, cloud-enabled, and web-scalable IT workloads with
  • configurable resource limits. To get the most out of this service,
  • deriving the right Kubernetes cluster architecture is essential. In
  • this course, you'll explore how Kubernetes built-in tools are used
  • to work with the overall Kubernetes system. You'll examine, among
  • other items, the Container Runtime Interface, workloads in
  • Kubernetes, and the lifecycle of a Pod. You'll then use kubeadm to
  • create and bootstrap Kubernetes clusters. You'll create deployments
  • with labels and employ label selectors to filter Kubernetes
  • objects. You'll utilize kubectl to deploy applications, inspect
  • cluster resources, authenticate against an API server, and modify
  • labels. You'll configure Kubernetes clusters to run a combination
  • of Linux and Windows nodes. You'll also create namespaces and
  • LimitRange objects and Pods for these namespaces.

Kubernetes Administrator: Managing Role-based Access Control

  • Role-based access control is an approach to restricting system

  • access to authorized users. Kubernetes supports multiple
  • authorization modules, including role-based access control, which
  • works using Role, ClusterRole, RoleBinding, and ClusterRoleBinding
  • objects, which are declared using RBAC API. In this course, you’ll
  • explore the concept of authorization and the authorization modes
  • supported by Kubernetes. You’ll investigate how to control access
  • to the Kubernetes API server, including the prominent principles
  • for planning and implementing Kubernetes role-based access control,
  • the features of Role, ClusterRole, RoleBinding, and
  • ClusterRoleBinding objects. Next, you’ll utilize kubectl
  • subcommands and commands to query the API authorization layer,
  • enable the NamespaceLifecycle and LimitRanger admission control
  • plugins, and get a list of existing Roles, ClusterRoles,
  • RoleBindings, and ClusterRoleBindings from Kubernetes clusters.
  • You’ll then create a file and use it to create a Role, ClusterRole,
  • RoleBinding, and ClusterRoleBinding. Next, you’ll create kubeconfig
  • files to allow users to perform operations in Kubernetes cluster
  • Namespaces. Finally, you’ll implement Aggregated ClusterRole and
  • use the AggregationRule to define label selectors and match other
  • ClusterRole objects.

Kubernetes Administrator: Underlying Cluster Infrastructure

  • Kubernetes infrastructure is a combination of multiple resources that includes servers, physical or virtual machines, cloud platforms, and more. Kubernetes architecture and components facilitate dynamic and on-demand provisioning of resources that are required to deploy Kubernetes clusters and their components.
  • In this course, you’ll explore the key considerations for Kubernetes deployment and review the pros and cons of the best known approaches for deploying Kubernetes. You’ll learn about node features, the recommended approach to provision and add nodes to Kubernetes clusters, and the process of upgrading Kubernetes clusters. Next, you’ll explore how to use kubectl commands to view a node's status, configure the default CPU requests and limits for namespaces, set quotas for total amount of memory and CPU for all containers running in a namespace, set quotas for total number of Pods that can run in a namespace, and set minimum and maximum values for CPU resources being used by containers and pods in a namespace.
  • Moving on, you’ll use kubeadm and kubectl commands to upgrade cluster control plane nodes from version 1.18.x to version 1.19.x and upgrade kubelet and kubectl on all cluster control plane nodes from version 1.18.x to version 1.19.x. Finally, you’ll discover how to upgrade kubeadm, kubelet, and kubectl on all cluster worker nodes from version 1.18.x to version 1.19.x.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Managing Kubernetes Deployments

  • Kubernetes supports deployments that represents a set of multiple Pods to run multiple replicas of an application and replaces the instances when they are unresponsive.
  • In this course you will recognize the key Kubernetes deployment strategies and the elements of the manifest file for the deployment strategies, review the workload resources that are used by Kubernetes to manage deployments and Pods. You’ll recognize the different states of deployment lifecycle, the scenarios of using the StatefulSet workload API object, including the components and the limitations associated with StatefulSet in deployments.
  • Next, you’ll implement deployments that create and bring three replicated Pods, define the selection rules to help deployments find which Pods to manage, update deployments, view rollout status and deployment update information.
  • Moving on, you’ll use Kubectl commands to inspect rollouts, pause and resume rollouts to rollback updates, check the revisions of deployments, rollback deployments, manage Pods, scale out and customize resource definition of deployments.
  • Next, you’ll use Kubectl commands to scale specific StatefulSet by increasing replicas, diagnose Pods. And finally, you’ll set up Autoscaler for deployment and specify the minimum and maximum number of Pods based on the CPU utilization of the existing Pods.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Configuring ConfigMaps & Kubernetes Secrets

  • Kubernetes uses ConfigMaps to store and share unencrypted configuration information. They bind configuration artifacts of Kubernetes to the Pod containers and system components dynamically.
  • In this course you’ll explore the role of ConfigMaps and the different approaches of using ConfigMaps along with the different types of Kubernetes Secrets and the different approaches of using Secrets in Pods. You’ll create ConfigMaps from single file, multiple files, and from generators.
  • Next, you’ll create ConfigMaps containing multiple key-value pairs and use ConfigMaps to define environment variables.
  • Moving on, you’ll create Secrets using a Secret config file, by defining a secretGenerator and also define container environment variables using the date from Secrets.
  • Finally, you’ll use the Kubectl apply command to create a Pod, provide access to the Secret data through a volume, create an imagePullSecret and add image pull secret to the service account.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Scaling & Managing Resources

  • Kubernetes provides the capability to dynamically scale deployments in order to scale the number of Pods in a deployment up or down and add resiliency using various commands and tools.
  • In this course you’ll recognize what a DaemonSet is, the patterns for communicating with the Pods in a DaemonSet, the role of Kubernetes Garbage Collector, and the resource types and resource units used in Kubernetes. You’ll review the commands used to manage Kubernetes objects, and the features of tools used for templating YAML in Kubernetes.Next, you’ll create a deployment and scale the deployment, scale StatefulSets and make in-place updates, and create a defined Horizontal Pod Autoscaler and DaemonSet.
  • Moving on, you’ll create jobs and list all the Pods that belong to the jobs. You'll see how to deploy a replicated topology with a StatefulSet controller, simulate Pod and Node downtime, and implement a case study of cascading deletion and managing orphans dependents. Finally, you’ll use the Kustomize tool to demonstrate the composition of deployment and service resources and install Helm and Service Catalog in Kubernetes clusters.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Managing Pods & Deployments

  • Kubernetes uses pods to wrap up one or more containers. The primary objective of deployments is to declare the number of replicas of a pod that should be running at a time and also ensure the pods' availability by recreating them when they are not available.
  • In this course, you'll learn to perform critical pod and deployment tasks, which includes creating a ReplicaSet definition file, using kubectl commands to create a ReplicaSet, verifying management of pods by specific ReplicaSets, removing ReplicaSet-managed pods, and increasing the number of pods when the CPU load gets higher without exceeding five pods. Next, you’ll create a deployment definition file and use the kubectl command to deploy four pods with NGINX. You'll also use the kubectl scale command to scale replicas, create a Kubernetes user account using the X509 client certificate, schedule and launch pods, and taint a node.
  • Moving on, you’ll create a manifest file that creates a pod with a sample container, manually schedule a pod and force a pod to be on a specific node, and use kubectl commands to create a pod and configure environment variables. Finally, you’ll create a secret from files containing a username and password, define environment variables, and mount the secret to a pod.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Configuring Networking & Services

  • Kubernetes Service defines a logical set of pods, a policy to access them and provide efficiency to the microservices deployed in the clusters. Kubernetes networking uses iptables to manage network connections between pods and nodes to enable communication across Kubernetes cluster components.
  • In this course you’ll investigate the Kubernetes Network model, the technologies that can be used to implement the Kubernetes Networking model, the challenges of pod networking, how services can help mitigate the challenges and why proxying is used for services. You’ll recognize the features of the prominent types of Kubernetes service, the role of EndpointSlices and the supported AddressTypes.
  • Next, you create a network namespace and list all the available namespaces, creates two HTTP server pods and verify the pods are running, create a service without a Pod selector, manually map the service to the network address where it's running and configure multiple port definitions on a service object.
  • Finally, you’ll create a configuration file to configure type NodePort and type LoadBalancer, create a deployment that runs 3 replicas of an application and create an internal TCP LoadBalancer using a service.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Service Management

  • Kubernetes classifies services into different types to facilitate restricting services within clusters, expose them on static ports, enable the use of cloud providers’ load balancer and facilitate load balanced and scalable Pods.
  • In this course you’ll investigate the primary modes for finding a Service supported by Kubernetes, the essential components used to implement automation of Service Accounts, the features provided by Service Catalog, the steps for listing Managed Services and Plans of a Service Broker and how to provision a new instance of a Managed Service.
  • Next, you’ll create pods running a NGINX cluster side address space and NGINX replicas, and create a service of types ClusterIP, NodePort, LoadBalancer and ExternalName.
  • Finally, you’ll visualize Service Account in the namespace, create additional Service Account objects and retrieve a dump of the Service Account object, modify the default Service Account for a namespace, use Secrets as imagePullSecret and also create, describe, delete and invalidate API tokens for a Service Account.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Ingress and Cluster DNS & CNI Management

  • Kubernetes uses Ingress to expose HTTP and HTTPS routes from outside the cluster to services within the cluster. It also facilitates DNS management by replacing Kube-DNS with CoreDNS, which is a flexible and extensible DNS server that can serve as the Kubernetes cluster DNS.
  • In this course you’ll recognize the role of Ingress in enabling routing, the prerequisites required to create and configure Ingress, the prominent Ingress controllers and when to implement them. You’ll recall the prominent PathTypes and the use of HostName wildcards, the features of CoreDNS and Kube-DNS along with the features of prominent network and CNI plugins.
  • Moving on, you’ll create a simple Ingress resource, update the configuration file to update the Ingress resource backend, configure the Ingress resource to run a web application behind external HTTPS load balancer and install CoreDNS as the default DNS service while installing a fresh Kubernetes cluster. Finally, you’ll upgrade the DNS service of existing Kubernetes clusters to CoreDNS, replace Kube-DNS and enforce network policies in Google Kubernetes Engine.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Managing StorageClass & Volume

  • Kubernetes manages Volumes and Containers by defining a low-level representation of a StorageVolume using PersistentVolume object and binding Pod and PersistentVolume using PersistentVolumeClaim.
  • In this course, you'll explore the applicable Reclaim policies and features of PersistentVolume, the concept of Node Affinity, the various phases of a Volume, the maximum number of volumes that can be attached to a Node, and how to configure custom limits.
  • Additionally, you'll create a storage device using AWS EBS and a PersistentVolume that uses the EBS, a PersistentVolumeClaim to use the PersistentVolume of an AWS EBS storage device, and a PersistentVolume with an EBS via AWS API and mount it to an AWS EC2 instance.
  • You'll also create a Pod that uses Dynamic PersistentVolumeClaim, delete PersistentVolume and PersistentVolumeClaim, change the Reclaim policy from Retain to Delete for PersistentVolume, and create a PersistentVolume using an existing Compute Engine persistent disk.
  • Finally, you'll create a Pod with two containers to exchange data, a deployment that uses a PersistentVolumeClaim to mount it as a Volume, and a Pod to mount the NFS Volume in a Docker container to the master node.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in its preparation.

Kubernetes Administrator: Troubleshooting Cluster Components

  • Troubleshooting is a critical yet complicated task in Kubernetes. Monitoring the right metrics and setting alerts is essential to identify an issue's root cause. In this course, you'll learn to dig deep and investigate every component of a Kubernetes cluster, uncovering the root causes of common Kubernetes issues and taking appropriate action to troubleshoot them.
  • Some of the items you'll explore include the Kubernetes components to consider when planning troubleshooting, the commands for troubleshooting cluster components, techniques for troubleshooting etcd database, and the critical problems and recommended troubleshooting approaches associated with managing Pods.
  • Items you'll practice troubleshooting include issues associated with kubeadm installation, Kubernetes cluster components, Kubernetes resource configuration, Kubernetes Services, Pods remaining in a pending and unschedulable state, and Pod failure CrashLoopBackOff scenarios.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in preparation for it.

Kubernetes Administrator: Using PersistentVolume & PersistentVolumeClaim

  • Kubernetes manages Volumes and Containers by defining low level representation of a StorageVolume using the PersistentVolume object and binding Pod and PersistentVolume using PersistentVolumeClaim.
  • In this course you’ll recall the applicable Reclaim policies and features for PersistentVolume, the concept of Node Affinity, the various phases of a Volume, the maximum number of volumes that can be attached to a Node and the approach of configuring custom limits.
  • Next, you’ll create a storage device using AWS EBS and a PersistentVolume that uses the EBS, create a PersistentVolumeClaim to use the PersistentVolume of AWS EBS storage device, create a PersistentVolume with an EBS via AWS API and mount it to AWS EC2 instance.
  • You’ll also create a Pod that uses Dynamic PersistentVolumeClaim, delete PersistentVolume and PersistentVolumeClaim, change the Reclaim policy from Retain to Delete for PersistentVolume and create a PersistentVolume using an existing Compute Engine persistent disk.
  • Finally, you’ll create a Pod with two containers to exchange data, create a deployment that uses a PersistentVolumeClaim to mount it as a Volume and create a Pod to mount the NFS Volume in a Docker container to the master node.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in its preparation.

Kubernetes Administrator: The Logging Mechanism

  • Kubernetes doesn't provide any native storage solution for log data, but it can be integrated with existing logging solutions. You can classify Kubernetes logs and manage them at the application and cluster level to enable observability and identify the root cause of issues. In this course, you'll learn how to do just that.
  • You'll kick off by exploring the Logging architecture of Kubernetes clusters, the different log types maintained in Kubernetes clusters, the Kubernetes architecture that helps manage logging at the node and cluster level, best practices for Kubernetes logging, the role of the Resource Metrics pipeline, and the architecture of Metric server.
  • Next, you'll configure a Pod specification with a container to write logs to standard output every 5 seconds and return snapshot logs from various Pod types.
  • Moving on, you'll configure a Pod to write two different log files using different formats, create a Pod with two sidecar containers, and inspect, debug, and get logs from applications.
  • Finally, you'll install the Metric server and use it to manage metrics for Nodes and Pods. You'll view Pod and Node resource metrics, create a Pod with one container, attach a Shell, and then execute commands in it.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in its preparation.

Kubernetes Administrator: Auditing & Customizing Logs

  • Kubernetes auditing helps administrators understand and investigate issues affecting their system. In this course, you'll use Kubernetes to create various audit policies, capture and print logs, and debug Pods, nodes, container runtimes, and applications.
  • You'll explore common issues associated with Pods and ReplicationController and the tools to aggregate different Kubernetes logging layers and log types.
  • You'll create a Deployment with two Pods, use kubectl to retrieve Pod information, the kubectl alpha debug command to add ephemeral containers to a running Pod, and stdout and stderr to write a configuration file and capture container logs.
  • Finally, you'll use crictl commands to debug container runtimes and Telepresence to create a virtual network.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in preparation for it.

Kubernetes Administrator: Monitoring Kubernetes Metrics

  • Monitoring the current state of system components is one of the most efficient ways to identify problems and bottlenecks in a production environment. Administrators working with Kubernetes need to know how to monitor at multiple levels, including at the node, cluster, and Pod levels.
  • In this course, you'll examine the vital Kubernetes performance metrics to monitor, what to measure in Kubernetes clusters, nodes, and Pods, and best practices for monitoring these. You'll also identify the differences between logging and monitoring.
  • Moving on, you'll write configuration files to create and start node-problem-detector. You'll then specify Pod configuration files to ensure kubelet performs liveness probes, HTTP GET requests are sent to the server running in the container, and TCP liveness probe readiness is defined.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in preparation for it.

Kubernetes Administrator: Managing Highly-available Clusters

  • An architecture is considered resilient if it is continuously operational and can sustain failures. Kubernetes high availability is all about setting up Kubernetes, along with its supporting components, in a way that leaves no single point of failure, and has the capability to detect hardware or software faults and remediate them.
  • In this course, you’ll learn the Kubeadm commands and flags that can be used to manage, bootstrap, and join Kubernetes clusters. You’ll explore the highly-available Kubernetes architecture, the benefits of multi-master HA architecture, and the advantages and disadvantages of approaches for setting up HA Kubernetes clusters. Next, you’ll investigate the stacked and external etcd topologies, the role of etcd in Kubernetes, and the concepts of leaders and elections. You’ll learn about the essential control plane components and how to back up etcd clusters and use them to recover Kubernetes clusters.
  • You'll examine how to create a load balancer for kube-apiserver and add control plane nodes to it, initialize a stacked control plane, and join multiple stacked control plane nodes. You’ll discover how to set up HA clusters with external etcd nodes, add additional control planes to the clusters, install workers after bootstrapping a control plane, and finally take snapshots using etcdctl commands and use the snapshots to restore clusters.
  • This course is part of a series that aligns with the objectives for the Certified Kubernetes Administrator exam and can be used to prepare for this exam.

Kubernetes Administrator: Troubleshooting Deployments & Networking

  • Reliable networking and deployments are critical in enabling robust and highly-available Kubernetes clusters. Continuous monitoring and the right diagnostic tools and commands help analyze network latency, performance, and availability.
  • In this course, you'll explore the built-in Kubernetes application debugging mechanism. Furthermore, you'll examine how to manage out-of-resource scenarios and frequently encountered Kubernetes deployment networking issues.
  • Moving along, you'll configure ReplicationController to ensure Pods are always up and apply configuration files to scale up applications and manage load. You'll use a Pod as a test environment to diagnose DNS problems and investigate Kubernetes network ingress, service traffic flows, and init container execution problems.
  • You'll inspect Kubernetes iptables rules used for virtual IP translation and Service IP load balancing and gracefully delete StatefulSet Pods.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in preparation for it.

Kubernetes Administrator: Troubleshooting Cloud-hosted Kubernetes

  • Cloud-hosted Kubernetes clusters benefit from underlying cloud capabilities but are not immune to issues related to workload management and Pod availability. Administrators need to investigate and swiftly resolve such issues by adopting the most efficient and effective troubleshooting approaches.
  • In this course, you'll examine the recommended options for customizing Kubernetes clusters, how extension points interact with Kubernetes Control Plane, the log files present on a cluster's master and worker nodes, and master and worker node critical entries that help identify issues.
  • To complete this course, you'll practice resolving potential problems associated with using Google Kubernetes Engine (GKE) and fix common issues related to deployed workloads on Google Kubernetes clusters. Lastly, you'll set up a Kubernetes cluster to ingest logs into Elasticsearch and visualize the metrics using Kibana.
  • This course is part of a series that aligns with the Certified Kubernetes Administrator exam's objectives and can be used in preparation for it.

Opties bij cursus

Wij bieden, naast de training, in sommige gevallen ook diverse extra leermiddelen aan. Wanneer u zich gaat voorbereiden op een officieel examen dan raden wij aan om ook de extra leermiddelen te gebruiken die beschikbaar zijn bij deze training. Het kan voorkomen dat bij sommige cursussen alleen een examentraining en/of LiveLab beschikbaar is.

Examentraining (proefexamens)

In aanvulling op deze training kunt u een speciale examentraining aanschaffen. De examentraining bevat verschillende proefexamens die het echte examen dicht benaderen. Zowel qua vorm als qua inhoud. Dit is de ultieme manier om te testen of u klaar bent voor het examen. 

LiveLab

Als extra mogelijkheid bij deze training kunt u een LiveLab toevoegen. U voert de opdrachten uit op de echte hardware en/of software die van toepassing zijn op uw Lab. De LiveLabs worden volledig door ons gehost in de cloud. U heeft zelf dus alleen een browser nodig om gebruik te maken van de LiveLabs. In de LiveLab omgeving vindt u de opdrachten waarmee u direct kunt starten. De labomgevingen bestaan uit complete netwerken met bijvoorbeeld clients, servers, routers etc. Dit is de ultieme manier om uitgebreide praktijkervaring op te doen.

Waarom Icttrainingen.nl?

Via ons opleidingsconcept bespaar je tot 80% op trainingen

Start met leren wanneer je wilt. Je bepaalt zelf het gewenste tempo

Spar met medecursisten en profileer je als autoriteit in je vakgebied.

Ontvang na succesvolle afronding van je cursus het certificaat van deelname van Icttrainingen.nl

Krijg inzicht in uitgebreide voortgangsinformatie van jezelf of je medewerkers

Kennis opdoen met interactieve e-learning en uitgebreide praktijkopdrachten door gecertificeerde docenten

Bestelproces

Zodra wij uw order en betaling hebben verwerkt, zetten wij uw trainingen klaar en kunt u aan de slag. Heeft u toch nog vragen over ons orderproces kunt u onderstaande button raadplegen.

lees meer over het orderproces

Wat is inbegrepen?

Certificaat van deelname ja
Voortgangsbewaking ja
Award Winning E-learning ja
Geschikt voor mobiel ja
Kennis delen Onbeperkte toegang tot onze community met IT professionals
Studieadvies Onze consultants zijn beschikbaar om je te voorzien van studieadvies
Studiemateriaal Gecertificeerde docenten met uitgebreide kennis over de onderwerpen
Service Service via chat, telefoon, e-mail (razendsnel)

Platform

Na bestelling van je training krijg je toegang tot ons innovatieve leerplatform. Hier vind je al je gekochte (of gevolgde) trainingen, kan je eventueel cursisten aanmaken en krijg je toegang tot uitgebreide voortgangsinformatie.

Life Long Learning

Meerdere cursussen volgen? Misschien is ons Life Long Learning concept wel wat voor u

lees meer

Neem contact op

Studieadvies nodig? Neem contact op!


Contact