Accept the KVO EULA
KVO blocks all access, including the API, until the EULA is accepted in the browser. Open https://<kvo-ip>, read the Keysight Software EULA, click Agree, then log in with admin / admin.
Deploy CloudLens sensors to your EC2 instances in 5 to 10 minutes (small deployments) or 30 to 60 minutes (thousands of instances). A full 3-component stack (vController + KVO + vPB) was launched live in AWS us-east-1 and reached CREATE_COMPLETE. Linux, Windows, and agentless AWS VPC Traffic Mirroring, fully automated. The mirror session was verified end to end: tapped workload traffic reached the tool, confirmed packet by packet.
📄 Read the end-to-end runbook (PDF) · stack creation to a proven, packet-verified mirror, with the full architecture, every object, and the live evidence.
Launch Stack creates the CloudFormation stack only (the vController, KVO and vPB appliances plus networking). For the full automated pipeline that also licenses, adopts, installs sensors, and builds the packet-verified AWS mirror, use Run in CloudShell.
1 Copy this command
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash
2 Open CloudShell and paste it at the prompt
Open AWS CloudShellCloudShell cannot be handed a command through a link, so it always opens at an empty prompt. Paste the line above and press Enter.
Deploy them from AWS Marketplace in one click before running sensor deployments.
One CloudFormation stack. Provisions vController + KVO + vPB into a shared VPC with purpose-built mgmt, data, and tool subnets. About 15 minutes from click to ready.
Or deploy each product separately:
Central management for sensors. Required for any sensor deployment.
t3.xlarge, ready in about 15 minuteshttps://<vcontroller-ip>admin / Cl0udLens@dm!n (change on first login)Optional. Centralizes the vPB fleet and automates AWS VPC Traffic Mirroring.
c5.2xlarge (Marketplace-fixed)ssh -p 9022 admin@<kvo-ip> (port 9022, not 22)https://<kvo-ip>admin / admin (change on first login)Optional. For inline traffic processing and VXLAN aggregation.
t3.xlarge, multi-ENI layoutssh -p 9022 admin@<vpb-ip> (NOT port 22)sudo vpb ready on first SSHsudo vpb (works the moment you SSH in)After vController finishes initializing (about 15 minutes), open the UI, create a project, copy the project key, then return here to run the sensor deployment.
vController, KVO, and vPB are all available as Terraform modules in deploy/terraform. The stack module composes all three; the per-component modules deploy them individually: clms (vController), kvo, vpb. Same Marketplace AMIs, IaC-friendly for pipelines and repeatable deployments. The CloudFormation equivalents live in deploy/cloudformation.
cd deploy/terraform/stack
terraform init
terraform apply -var key_name=my-keypair -var deploy_kvo=true -var deploy_vpb=true
Every Launch button and the CLI take the same options. Leave them alone for a clean lab build, or set them to drop CloudLens into infrastructure the customer already runs.
Name a VPC and subnet and the stack creates no networking at all: no VPC, no subnets, no internet gateway, no routes. The instances land beside the workloads they monitor.
ExistingVpcId + ExistingSubnetId — required togetherExistingDataSubnetId — optional, puts the vPB data plane in its own subnetExistingSecurityGroupId — optional, attaches a pre-approved SG instead of creating one. AdminIngressCidr is then ignored.Leave ExistingVpcId blank and the four CIDR fields build a fresh VPC instead. That single field is the greenfield / brownfield switch.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash -s -- \
--existing-vpc-id vpc-0abc123 \
--existing-subnet-id subnet-0def456 \
--existing-sg-id sg-0aaa111
For anyone, SE or customer. The doctor finds every setup gap first and prints the exact fix; the deploy asks all of its questions before anything is built and saves your answers; the teardown removes only what it built.
# 1. Is this machine and account ready? Deploys nothing.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash -s -- --doctor --region us-east-1
# 2. Deploy. Every question comes first, then one Proceed.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash
# 3. Replay a saved deployment anywhere, zero questions (an SE fills the
# interview once; deploy-profile-<stack>.env is written at the plan step):
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash -s -- --profile ./deploy-profile-acme.env
# 4. Remove everything it created, when you are done. Audits first, asks before
# deleting. If the stack has a KVO it offers to release its licences first
# (or do it in the KVO: Settings > Product Licensing > Deactivate licenses).
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/teardown-stack.sh | bash -s -- --stack-name YOUR-STACK --region us-east-1
Every run ends with deploy-report-<stack>-<region>.html: what was built, where to sign in, what is tapped, how each phase ended, how to verify, and the exact teardown command. Passwords stay in the mode-600 files it points to, never in the page. Profiles never contain secrets either: licence codes and keys are always typed at the moment of use.
Both tapping paths resolve one selection from customer_input.yaml: ANDed tag_filters, explicit instance_ids, and tapping.exclude_instance_ids drive sensors and agentless mirroring identically, so the two can never target different hosts. The run reports the split up front: which hosts get sensors, which interfaces get mirror sessions (AWS mirrors Nitro instances only), and how many licence credits that demands.
--tapping sensors|mirror|both|none — one answer for both paths--source-vpc-id vpc-... — tap a VPC other than the CloudLens one; repeat it (or list aws.source_vpc_ids in customer_input.yaml) and one KVO fabric is built per VPC--source-vpc vpc:az:mgmt:ingress:egress — same, with that VPC's collector placement inline (three distinct subnets in the tapped VPC)--eks-cluster NAME / --eks-sample — tap Kubernetes pods in EKS. Pod-to-pod traffic inside a node is invisible to VM sensors and VPC mirroring; the CloudLens K8s sensor sees it. DaemonSet (one sensor per node, fully automated: image pushed to ECR, applied with kubectl, no helm needed) or sidecar (per-pod; your apps get a rendered snippet, never an automatic restart). --eks-sample builds a small test cluster plus a demo app generating continuous pod-to-pod HTTP. K8s sensors register into the same project as the VM sensors and follow the same tool path.A tapped VPC that is not the CloudLens VPC needs a route to the manager and KVO on 443 and to the tool from the collector egress subnet (VPC peering or Transit Gateway); the run states exactly that when it applies.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash -s -- \
--tapping both \
--source-vpc-id vpc-0workloads1 \
--collector-zone us-east-1a \
--collector-mgmt-subnet subnet-aaa --collector-ingress-subnet subnet-bbb --collector-egress-subnet subnet-ccc
Many enterprises forbid Elastic IPs on workload subnets. Set AssignPublicIp to no (or pass --no-public-ip) and no EIPs are created. The stack outputs private IPs and you reach the UIs over VPN, Direct Connect, or VPC peering.
A brand new AWS account has no key pairs, which used to block the wizard entirely. Now you choose:
<StackName>-key, EC2 stores the private key in SSM Parameter Store, and the stack outputs the exact command to download itKeyPairNameThe CLI lists the key pairs in your region and lets you pick one or create a new one. In the console it is a text box rather than a dropdown, because CloudFormation cannot make a key pair dropdown optional: a dropdown must always resolve to an existing key, which is exactly what blocks a first deploy.
# Download the auto-created private key (the stack prints this command)
aws ssm get-parameter --name /ec2/keypair/<key-pair-id> --region <region> \
--with-decryption --query Parameter.Value --output text > my-key.pem && chmod 400 my-key.pem
CloudFormation builds in dependency order, so resources appear in waves rather than all at once. Timings below are from a real deploy of vController plus three test VMs in us-east-1. Watch it live on the Events tab, or the Timeline view for a Gantt chart.
Status goes CREATE_IN_PROGRESS. Nothing exists yet.
VPC, then the internet gateway and its attachment. Skipped entirely if you supplied an existing VPC.
The mgmt, data, and tool subnets appear together, then their route table associations. Also the security groups.
A short Lambda confirms the account has enough Elastic IPs for this stack. This is the gate: if it fails, the stack stops here with a message naming the shortfall and no instance is ever launched. See Common issues.
vController, then KVO and vPB if selected, plus any test workloads. They start in parallel, so this is one wave rather than three.
Addresses were allocated earlier; here they are associated with the running instances.
Infrastructure is done. Read the Outputs tab for UI URLs, SSH commands, and the test VM addresses.
If the stack rolls back, open the Events tab and sort oldest first: the first CREATE_FAILED row is the real cause, everything after it is cleanup.
vController, KVO, and vPB plus sensors. End to end. From a single paste.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash
Prompts for region and key pair, accepts Marketplace terms, deploys vController, waits for initialization, optionally adds KVO and vPB, then chains to sensor deployment. Run from AWS CloudShell or any machine with the AWS CLI.
One paste, end to end. Best for: trying it the first time, or onboarding a new customer.
Single command, vController plus KVO and vPB. Best for: IaC pipelines and repeatable infra.
cd deploy/terraform && terraform init && terraform apply \
-var key_name=my-keypair -var deploy_kvo=true -var deploy_vpb=true
Executive-friendly PDF guide. Best for: customer CTO, procurement, training.
Download RunbookSame discipline in reverse. It removes what this deployment created, and nothing else.
1. See what is loose first. Read-only, deletes nothing: the stack, what it left behind, and what that is costing. Put your stack name and region in.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/teardown-stack.sh | bash -s -- --stack-name YOUR-STACK --region YOUR-REGION --orphans
2. Tear it down. Audits again, shows what it found, and asks you to confirm before deleting. If the stack has a KVO, the script then lists the licences it holds and offers to release them before anything is deleted (default yes on a terminal; --release-licences answers it without one): they come back while the KVO is alive and never afterwards, and the teardown is confirmed first so licences are only stripped from a KVO you have already chosen to destroy. Only a release that leaves the KVO clear skips the licence-loss confirmation; anything else is explained and the typed stack name is still required. The UI route remains: release them yourself first under Settings > Product Licensing > Deactivate licenses, then run the teardown.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/teardown-stack.sh | bash -s -- --stack-name YOUR-STACK --region YOUR-REGION
Deleting the CloudFormation stack on its own is not enough, and that surprises people. The Marketplace AMIs set DeleteOnTermination=false, so on any stack launched before 15 September 2026 the root volumes survive as available and keep billing; the templates now override that, and this script sweeps such volumes either way. KVO creates the collector Auto Scaling group and its security groups outside CloudFormation, so the stack cannot see them, and a VPC still holding them cannot be deleted. CloudFormation can then report DELETE_COMPLETE and still leave the whole network standing. This script deletes the stack and sweeps the volumes, security groups, scaling groups and launch templates it can attribute to it. If the VPC itself outlives the stack, run --orphans afterwards to see what is still standing, and remove the VPC by hand.
It only removes what your deployment built. Nothing is deleted unless AWS itself ties it to your stack, by stack membership, by living in the VPC that stack created, or by an owner tag naming it. Anything without that evidence is reported and left alone, because in a shared account "it was unattached" is not proof of ownership. Brownfield deploys into an existing VPC (--existing-vpc-id) switch the VPC rule off entirely: that network is the customer's, and its other contents are none of the script's business. Stack name and region are yours to pass, so the same command is safe in any account.
Add --orphans to audit without deleting, --dry-run to print every command it would run, or --sweep-only to clean up after a stack that is already gone. Nothing is removed without an explicit confirmation, or --yes in a pipeline.
For SE demos or first-call verification: stand up 3 throwaway workload EC2 instances (Ubuntu 22.04 + RHEL 9 + Windows Server 2022) tagged with a discovery tag, then run the stack with the matching tag flags. Proves sensors install on every supported OS in one pass.
# 1. Stand up the 3 test workload instances (default tag: cloudlens=yes)
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/scripts/deploy-test-workload-vms.sh | bash
# 2. Deploy the CloudLens stack, then run sensor deployment against the tagged instances
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash
# 3. Cleanup when done
aws cloudformation delete-stack --stack-name cloudlens-test-vms --region us-east-1
The fixture launches three instances tagged cloudlens=yes with an os tag per platform. The sensor deployment installs on all three and they register with vController. Total round trip: about 25 to 30 minutes. Override the tag pair with TESTVMS_TAG_KEY / TESTVMS_TAG_VALUE environment variables if you want to mirror a customer's existing convention.
Pinned image with Ansible, the AWS SDKs, and pywinrm. Works from your laptop, a CI runner, or any container host.
docker run --rm -it \
-v $(pwd)/customer_input.yaml:/work/customer_input.yaml \
-v $HOME/.ssh:/root/.ssh:ro \
-e AWS_ACCESS_KEY_ID -e AWS_SECRET_ACCESS_KEY \
-e AWS_DEFAULT_REGION \
ghcr.io/keysight-tech/cloudlens-ansible-aws:latest
AWS credentials are passed via environment variables (use scripts/setup_aws_creds.sh to configure a profile). Same behavior as the CloudShell quickstart, just packaged for CI/CD or repeat customer deployments.
Image is published to GitHub Container Registry on every push to main: ghcr.io/keysight-tech/cloudlens-ansible-aws.
Prefer to build your own image instead of pulling? The Dockerfile is in the repo root.
git clone https://github.com/Keysight-Tech/cloudlens-ansible-aws.git
cd cloudlens-ansible-aws
docker build -t cloudlens-ansible-aws .
Drop the same docker run into GitHub Actions, GitLab CI, Jenkins, or CodeBuild. Mount your customer_input.yaml as a build artifact.
Pick a path and run it, the fabric diagram wires itself up as each step completes, with the plain-English narration and the raw output alongside. This is a live visualization of the real sequences; the actual deploy runs in your CloudShell.
Prefer it full-screen? Open the full console →
Most deployments under 50 instances complete in 5 to 10 minutes.
You need these in place before deploying:
If you do not have vController deployed yet, use the Launch vController button above.
The deployment discovers instances by tag. Apply these to every target instance:
| Tag | Value |
|---|---|
cloudlens | yes |
os | ubuntu or rhel or windows |
env | prod (or dev, qa) |
Tag a single instance:
aws ec2 create-tags --resources i-0123456789abcdef0 \
--tags Key=cloudlens,Value=yes Key=os,Value=ubuntu Key=env,Value=prod
Use the wizard below to fill the fields and download customer_input.yaml.
Tip: the wizard shows the YAML rendering live as you type. Each field has inline help so you know exactly what to enter.
Place your downloaded customer_input.yaml in your working directory, then pick one of the three deploy paths.
One click. No local tools. Best for: trying it for the first time.
Launch StackAlready authenticated. One curl command. Best for: most customers.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/quickstart.sh | bash
Reproducible. Pinned versions. Best for: CI or repeat deployments.
docker run --rm -it -v $(pwd)/customer_input.yaml:/work/customer_input.yaml ghcr.io/keysight-tech/cloudlens-ansible-aws:latest
Open your vController web UI and confirm:
Stuck? See the troubleshooting section below or the full troubleshooting docs.
Fill in four fields. Download the file. Run quickstart. That is the whole flow.
A single Ansible control point authenticates to AWS, discovers EC2 instances by tag, and routes each host to the right OS lane. The CloudLens sensor on each EC2 instance mirrors traffic (mirror / VXLAN) to the vPB, which forwards to your monitoring tool. Every sensor self registers with vController on first start.
Flow: CloudLens sensor on EC2 to mirror / VXLAN to vPB to monitoring tool. The dotted line shows sensor registration traffic back to vController.
Drag the slider to see the estimated deployment time for your fleet size.
A full 3-component stack was launched via CloudFormation in us-east-1 and reached CREATE_COMPLETE, then the full pipeline was proven end to end: KVO licensing, vController and vPB adoption, 3-OS sensor registration, and agentless AWS mirror sessions.
| Component | Result | Instance type |
|---|---|---|
| CloudLens vController (control plane) | CREATE_COMPLETE | t3.xlarge |
| Vision Orchestrator (KVO) | CREATE_COMPLETE | c5.2xlarge |
| Virtual Packet Broker (vPB) | CREATE_COMPLETE | t3.xlarge |
| Full stack (stack.yaml) | 3/3 live in us-east-1 | Shared VPC |
Once CloudFormation or Terraform finishes, configure the Keysight products via their web UIs. One-time setup, about 15 minutes end to end. vController was formerly named CLMS.
KVO blocks all access, including the API, until the EULA is accepted in the browser. Open https://<kvo-ip>, read the Keysight Software EULA, click Agree, then log in with admin / admin.
Navigate to Settings, Product Licensing, Activate. Three licenses must be enabled: vPB Advanced, CloudLens Enterprise, and KVO perpetual. If the license server is unreachable, copy the offline activation key from your Keysight portal.
From KVO: Inventory, CloudLens Manager, Discover. Enter the vController private IP and the admin credentials (admin / Cl0udLens@dm!n), and commit the change request KVO raises. Status must turn CONNECTED.
Then create the Cloud Config, Visibility Fabric, Cloud Configs, New, Custom Cloud. This provisions the real project on the vController and returns the sensor key; skip it and the key is a phantom that won't register sensors.
SSH to the vPB on port 9022 (not 22). The kvo command is an interactive context, not flat commands, run sudo vpb and enter it:
CloudLensVPB# kvo
CloudLensVPB-kvo# ip <kvo-private-ip>
CloudLensVPB-kvo# port 443
CloudLensVPB-kvo# enable # prints "KVO enabled"
CloudLensVPB-kvo# exit
kvo ip <x> / kvo enable as flat commands does not enable KVO. You must enter the context first.The vPB self-announces and appears under Inventory, Devices, Auto Discovery within ~30 s. Adopt it with Control the adopted device enabled, KVO consumes a device license, the vPB is auto-licensed, comes up Online, and KVO auto-creates its Device Config.
Bind the Device Config ports and connect the fabric so the vPB collects, filters, and forwards to a tool:
A tapping vPB needs 3 NICs (mgmt / ingress / egress), the stack wires these automatically when Zone Tapping is enabled.
Skip this if you used the disposable test fixture, those instances are already configured. Deploying sensors to existing customer EC2 instances? Prep them with the included script in scan-then-fix mode.
Auto-fix: Yes
Each instance needs AmazonSSMManagedInstanceCore attached to its instance profile. The prep script creates a CloudLens-SSM-Role and attaches it for you. If the instance already has an IAM role, the script adds the SSM policy to it instead of replacing.
Auto-fix: Mostly
Pre-installed on Amazon Linux, Ubuntu 16.04+, Windows Server 2016+. Must be installed manually on RHEL/CentOS, commands below.
Auto-fix: Yes
The script auto-detects each instance OS and applies cloudlens=yes plus the correct os tag (ubuntu, rhel, or windows).
Run scan-only mode to see what is missing before changing anything:
./scripts/deploy.sh --region us-east-1 --profile customer --scan-only
Once you have reviewed the scan, run with --auto-fix to remediate every gap in one shot:
./scripts/deploy.sh --region us-east-1 --profile customer --auto-fix
Omit --auto-fix for interactive mode, the script prompts before each change.
sudo snap install amazon-ssm-agent --classic
sudo systemctl enable snap.amazon-ssm-agent.amazon-ssm-agent.service
sudo systemctl start snap.amazon-ssm-agent.amazon-ssm-agent.service
sudo dnf install -y \
https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm
sudo systemctl enable amazon-ssm-agent
sudo systemctl start amazon-ssm-agent
# SSM Agent is pre-installed on Windows Server 2016+
# If it is not responding, restart it:
Restart-Service AmazonSSMAgent
aws ssm describe-instance-information --region us-east-1Push CloudLens sensors to every tagged EC2 instance at fleet scale over SSH, SSM, or WinRM, with outbound HTTPS from each instance back to vController.
Apply the marker tag cloudlens = yes and an os tag to every target instance. Without these the deployment skips the host.
| OS | Tag os |
|---|---|
| Ubuntu / Debian | ubuntu |
| RHEL / CentOS / Amazon Linux | rhel |
| Windows Server 2016+ | windows |
Each instance needs the managed policy AmazonSSMManagedInstanceCore attached to its instance profile for the SSM connection path. The included prep step can attach this for you and verify the SSM Agent is running.
Each instance must reach ssm.<region>.amazonaws.com, ec2messages.<region>.amazonaws.com, and ssmmessages.<region>.amazonaws.com on 443 outbound, or have a VPC endpoint to those services.
# Deploy to ALL tagged targets in the region
bash quickstart.sh
# Or run the playbook directly with your customer_input.yaml
ansible-playbook deploy.yaml -e @customer_input.yaml
The playbook invokes the CloudLens sensor installer on every matching instance in parallel, Docker or Podman on Linux, MSI on Windows. Sensors register with vController on first start.
No sensor in the guest. KVO deploys collector Service VMs and drives AWS VPC Traffic Mirroring, AWS copies traffic from every selected Nitro source ENI to the collectors, which forward it to your tool. Real AWS resources: mirror targets, filters, and one session per source ENI.
Mirroring is KVO calling AWS on your behalf, so it needs credentials. Enable the opt-in, least-privilege Zone-Tapping policy (deploy/iam/cloudlens-zonetap-policy.json): greenfield with EnableZoneTapping=yes (CloudFormation) or enable_zone_tapping="true" (Terraform), brownfield with scripts/kvo_enable_zonetap_iam.sh.
AWS VPC Traffic Mirroring only taps Nitro instances, CloudLens inherits this AWS limit. t3 / m5 / c5 / r5 and newer are Nitro (confirm with describe-instance-types … Hypervisor). Non-Nitro hosts can't be tapped, put sensors on those. Sources are selected by the cloudlens=yes tag, the same tag the sensor path uses.
On KVO: Cloud Fabric, Cloud Configs, New, AWS. Supply the region and source VPC, the collector image (auto-resolved per region), the SSH key and mgmt / ingress / egress subnets, then commit, KVO deploys an auto-scaling group of collector Service VMs. Under Visibility Fabric, Tools create the destination tool (Local or Remote) the mirrored traffic is forwarded to.
In KVO: Monitoring Policies, New, pick the source (the cloudlens=yes cloud collection) and the tool. KVO creates the Traffic Mirror target and filter, then one session per source ENI. Confirm with aws ec2 describe-traffic-mirror-sessions or under VPC, Traffic Mirroring.
Mix and match, mirror the Nitro hosts agentlessly and put sensors on the rest, both land under the same vController / KVO project.
Clean removal of sensors and infrastructure. Always run in this order, sensors first, infrastructure second.
# Remove sensors from all tagged targets
bash cleanup.yaml
# Or via the playbook
ansible-playbook cleanup.yaml -e @customer_input.yaml
Terraform path:
cd deploy/terraform
terraform destroy
CloudFormation path, use the teardown script rather than a bare delete-stack:
bash deploy/teardown-stack.sh \
--stack-name cloudlens-stack \
--region us-east-1
A bare delete-stack leaves the appliance root volumes billing, leaves the collector Auto Scaling group rebuilding itself, and can report DELETE_COMPLETE while the VPC is still standing. The script handles all three and verifies the result. See One command back down.
Default credentials, network topology, and Marketplace AMIs. Keep this open in a tab during deployment.
| Item | What to know |
|---|---|
vPB kvo | An interactive context, enter kvo, then ip / port 443 / enable / exit. Flat commands don't enable it. |
| vPB license | Auto-applied on adoption from KVO's device licenses, no manual license server. |
| AWS mirroring | Nitro sources only (t3 / m5 / c5 / r5+). Non-Nitro, use sensors. |
| Source tag | cloudlens=yes drives both the sensor and the mirror paths. |
| Key ports | 443 vController / KVO API · 9022 vPB SSH · 8443 KVO↔collector. |
| After CREATE_COMPLETE | Appliances need ~15 min to initialize before the UI accepts a login. |
| Product | Username | Password |
|---|---|---|
| KVO | admin | admin |
| vController | admin | Cl0udLens@dm!n |
| vPB SSH (port 9022) | ec2-user | key pair |
Change these on first login. Default passwords are not for production.
| Subnet | CIDR | Purpose |
|---|---|---|
| Management | 10.0.1.0/24 | SSH, HTTPS, REST API |
| Data | 10.0.2.0/24 | Sensor traffic (mirror / VXLAN) |
| Tool | 10.0.3.0/24 | Processed traffic to tools |
CIDRs are configurable in the CloudFormation parameters.
| Product | Instance |
|---|---|
| vController (CLMS_6.12.x) | t3.xlarge |
| KVO (2.13.x) | c5.2xlarge only |
| vPB-KVO (3.13.x) | t3.xlarge |
KVO has an AWS Marketplace instance-type restriction and cannot be changed.
If something does not work, check these first.
No. A run can stop for ordinary reasons: Ansible is not installed yet, there is nothing tagged to put a sensor on, an SSO token expires, a laptop sleeps. None of that loses the infrastructure already built.
Re-run the same command with --resume. It checks the real system rather than a state file: CloudFormation for the stack, the vController API, the KVO licensing API. Everything already finished is skipped and it picks up at the first unfinished step, usually in about a minute.
curl -sSL https://raw.githubusercontent.com/Keysight-Tech/cloudlens-ansible-aws/main/deploy/deploy-stack.sh | bash -s -- \
--region us-east-1 --stack-name cloudlens-stack --resume
Related: --fresh runs every phase again and skips nothing; --from PHASE starts at a named phase (stack, wait, key, license, adopt, sensors, vpb, path, mirror); --only PHASE runs exactly one.
Nothing in the deploy script deletes anything, including under --fresh. Teardown is a separate, explicitly confirmed command.
You are out of Elastic IPs. The default quota is 5 per region, and the full stack needs 3 (one each for vController, KVO, and vPB). If the account already holds EIPs, the deploy runs for several minutes, allocates what it can, then fails on the last one and rolls the whole stack back.
The usual cause is orphaned EIPs: terminating a stack's instances from the EC2 console leaves the CloudFormation stack, and its Elastic IPs, in place. They bill hourly while attached to nothing, and they block the next deploy.
List anything unattached:
aws ec2 describe-addresses --region us-east-1 \
--query 'Addresses[?AssociationId==`null`].[PublicIp,AllocationId,Tags[?Key==`Name`]|[0].Value]' \
--output table
If they belong to a stack whose instances are already gone, delete the stack so it does not simply recreate them:
aws cloudformation delete-stack --stack-name <name> --region us-east-1
Otherwise release them directly:
aws ec2 describe-addresses --region us-east-1 \
--query 'Addresses[?AssociationId==`null`].AllocationId' --output text \
| tr '\t' '\n' | xargs -I{} aws ec2 release-address --region us-east-1 --allocation-id {}
Alternatives: request a quota increase, or deploy with no public IPs at all using --no-public-ip (see Deployment options) and reach the stack over VPN, Direct Connect, or peering.
deploy-stack.sh now checks this before deploying and tells you which addresses to free, so you get the message in seconds instead of after a rollback.
Use the Launch vController button at the top of this page, or launch the full stack with the Launch CloudLens Stack button above. vController comes from AWS Marketplace, deploys in about 15 minutes, and is ready before you start tagging your instances. While you are there, also deploy KVO if you want centralized fleet orchestration across multiple vPB instances.
The vPB image uses port 9022 for SSH, NOT the default port 22. Keysight CloudLens OS (KCOS) binds sshd only to 9022 on the public interface. Connections to :22 time out forever even after the instance is fully booted.
What to do: wait 10 to 15 minutes after deploy succeeds for KCOS to initialize, then:
ssh -p 9022 admin@<vpb-public-ip> # OS shell
sudo vpb # vPB CLI
Security group rule: make sure the security group on the vPB management ENI allows inbound TCP on port 9022. The stack template opens this automatically; if you deployed via a custom path, add the rule manually.
Same vController note: the web UI on port 443 is usually ready within 60 seconds, but full system initialization (registry and project creation) takes around 15 minutes.
Cause: tags missing or misspelled.
Fix: verify with aws ec2 describe-tags --filters "Name=resource-id,Values=i-0123...". The cloudlens, os, and env tags must all be present.
Cause: your key pair is not on the target instance, or the wrong SSH user.
Fix: use ubuntu for Ubuntu and ec2-user for RHEL/Amazon Linux, and confirm ssh_key_path in customer_input.yaml points at the right .pem. For no-key targets, use the SSM connection path instead.
Cause: for the SSM path, the SSM Agent is not registered or the instance lacks the SSM IAM role; for the WinRM path, ports 5985/5986 are closed.
Fix: prefer windows_connection: "ssm", attach AmazonSSMManagedInstanceCore, and confirm the instance appears in aws ssm describe-instance-information.
Cause: wrong project key, or sensor cannot reach vController on the network.
Fix: double-check the project key from the vController UI. Verify the instance can reach vController on port 443.
1 to 50 instances: 5 to 10 minutes.
50 to 500 instances: 15 to 30 minutes.
500 to 2000 instances: 30 to 60 minutes.
Thousands: sharded automatically, 30 to 60 minutes for up to 10K.
Open an issue on GitHub, or contact your Keysight account team for direct engineering support.
Everything you need to deploy with confidence.
Every port, password, SSH gotcha, KVO adoption step, and security group rule. Read this before filing a support ticket.
Scenarios, architecture, scaling, and troubleshooting on GitHub.
Printable customer-ready guide with screenshots and checklists.
Copy-paste handoff message for your account team.
Bug reports and feature requests, handled by Keysight engineering.