Search
30 results for “iscsi”
Search results
Hands-On Lab: Scalable Hyper-V Storage with iSCSI, VHDs & Storage Pools
Virtual Disks, Storage Pools, and iSCSI - The Hidden Challenges of Hyper-V Storage (And How I Solved Them)
What is cache stampede and how do you prevent it?
A cache stampede happens when a popular cache key expires and many concurrent requests all miss at once, each falling through to hit the (often slow) origin, database or upstream API, simultaneously, sometimes overwhelming it. Common mitigations: a short-lived lock so only one request repopulates the cache while others wait or serve stale data (the "thundering herd" lock pattern), staggered/jittered TTLs so keys do not all expire at the same instant, and serving stale-while-revalidate, returning the expired value immediately while refreshing it in the background.
What is a Service Control Policy (SCP), and what is the one thing it does not do?
An SCP is a policy attached to an AWS Organizations root, organizational unit, or member account that defines the maximum available permissions for every identity in that account, including that account's own administrators and its root user. What an SCP does not do is grant any permission by itself, it only sets a ceiling; an identity still needs an actual IAM allow (from an identity-based or resource-based policy) within that ceiling to do anything. An SCP with no matching IAM allow underneath it results in access denied, not access granted, which is the most common misunderstanding of how SCPs work. One exception worth knowing: SCPs never apply to the organization's management account itself, only to member accounts.
What is the difference between durability and availability in S3, and why does it matter when picking a storage class?
Durability is the probability that a stored object is not lost over a year, and S3 Standard, Standard-IA, and every Glacier class are all designed for the same 99.999999999% (11 nines) durability. Availability is how often the object can actually be successfully retrieved on demand, and that number does vary by class, 99.99% for Standard down to 99.5% for One Zone-IA. It matters because a cheaper class is not automatically a less durable one, S3 One Zone-IA is exactly as durable as Standard-IA per object, but it is not resilient to the loss of its single Availability Zone at all, since it isn't replicated across multiple zones the way every multi-AZ class is.
What is the difference between a public and a private subnet in a VPC?
The difference is entirely about the subnet's route table, not any property of the subnet itself: a public subnet has a route to an internet gateway for `0.0.0.0/0`, so resources with a public IP in it can reach and be reached from the internet directly. A private subnet has no such route, so its resources typically use a NAT gateway (in a public subnet) for outbound-only internet access, or no internet path at all. Both subnet types can otherwise have identical security group and NACL configuration; "public" and "private" describe reachability via routing, not a separate networking feature.
What is a managed identity, and what problem does it solve compared to a service principal with a client secret?
A managed identity is an Entra ID identity automatically managed by Azure for a resource (a VM, an App Service, a Function), with credentials that Azure handles entirely, no client secret is ever stored, retrieved, or rotated by the application. A traditional service principal with a client secret requires that secret to be stored somewhere (a config file, a key vault) and rotated manually or via automation, which is itself a credential-management burden and a leak risk. Managed identities remove that burden for the common case of "this Azure resource needs to authenticate to another Azure service," which is why they're preferred whenever the workload runs on Azure compute.
What is an Azure VM Scale Set, and how does it differ from manually managing a group of VMs?
A VM Scale Set manages a group of identical, load-balanced VMs as a single logical unit, with built-in autoscaling based on metrics (CPU, custom metrics) and automated instance replacement on failure. Manually managing individual VMs means each scaling or patching action has to be repeated per instance, with no built-in mechanism to keep the fleet at a consistent size or to react automatically to load. Scale Sets are the IaaS-level building block that makes "run N identical VMs that scale with load" a supported, declarative configuration instead of a hand-rolled script.
What is the cloud shared responsibility model, and why does it matter for security?
It's the explicit division of security obligations between the cloud provider and the customer, and where that line falls depends on the service model. The provider is always responsible for "security of the cloud", physical data centers, host infrastructure, and (for managed services) the underlying platform. The customer is always responsible for "security in the cloud", for IaaS, that includes OS patching, network configuration, and IAM; for PaaS, it narrows to application code, data, and access control; for SaaS, it's mostly just access control and data. Misunderstanding this line is one of the most common causes of real cloud security incidents, assuming the provider handles something they explicitly don't.
What is a shard key, and why does a low-cardinality shard key (few distinct values) cause a hot shard?
A shard key is the field (or fields) a sharded database uses to decide which shard each document or row actually lives on. If that field has few distinct values, say `country`, and the real data is skewed (80% of users in one country), the vast majority of documents route to the same shard regardless of how many shards exist in the cluster, overwhelming it with disproportionate read/write load and storage while other shards sit comparatively idle. Cardinality alone doesn't guarantee even distribution either, the values also need to actually occur with reasonably even frequency in the real data, not just theoretically have many possible values.
What is the Filesystem Hierarchy Standard, and why does it matter that /etc, /var, and /usr are separate directories rather than one flat structure?
The FHS is a specification for where files belong on a Unix-like system, so that any compliant distribution places configuration, variable data, and installed software in predictable locations regardless of vendor. Separating them matters operationally: /etc holds host-specific configuration that should be backed up and version-controlled, /var holds logs, caches, and other data that grows and changes constantly and often lives on its own disk or partition for capacity/IO reasons, and /usr holds installed programs and libraries that are typically read-only at runtime and can be shared or mounted the same way across many machines. Collapsing them into one flat structure would make it much harder to back up only what matters, mount storage with the right characteristics per use case, or reason about what's safe to wipe and reinstall.
In a systemd unit, what is the practical difference between Type=simple and Type=forking, and why does that distinction matter for dependency ordering?
With Type=simple, systemd considers the unit started the moment the main process is forked off, it does not wait for the application to finish its own initialization, so anything depending on that unit might start before the service is actually ready to handle requests. Type=forking expects the traditional daemon pattern, the initial process forks and exits once it judges its own startup complete, so systemd marks the unit started as soon as that original process exits successfully, while the actual daemon keeps running as a separate, now-orphaned process. That only tracks the daemonization handoff, not genuine application readiness, a process can exit believing setup is done while it is still finishing initialization in the background, so Type=forking is a better signal than Type=simple but still not a readiness guarantee. Type=notify is the one that actually is readiness-safe: the service explicitly calls sd_notify to tell systemd exactly when it's ready, rather than systemd inferring readiness from process exit behavior at all.
What is a stale closure and how does it happen with useEffect?
A stale closure happens when a function captures a variable from a render that is no longer current, because the effect or callback was not re-created when that variable changed. Classic case: an effect with an empty dependency array reads a piece of state, since the effect only runs once, the function it closes over always sees the state value from the first render, not the latest one. The fix is to include the variable in the dependency array (or use a functional state update that does not need to read the outer value at all).
Why is committing a secret to version control worse than a normal security mistake to fix?
Deleting the file or even force-pushing over the commit doesn't remove the secret's exposure, the value lives on in the repository's commit history, in any fork or local clone already made, and often in CI logs that referenced it. The only real fix is treating the secret as permanently compromised: revoke and rotate it at the source (the database, the cloud provider, the API), then clean up history as a secondary, defense-in-depth step, not the actual remediation. This is why prevention (pre-commit scanning, never typing a real secret into a tracked file) matters far more for secrets than for most other classes of bugs.
What is the difference between SAST, SCA, and DAST, and where does each run in a pipeline?
SAST (static application security testing) analyzes an application's own source code without running it, catching issues like injection-prone patterns early in the build stage, before an artifact even exists. SCA (software composition analysis) scans a project's third-party dependencies against known-vulnerability databases, since most of a modern application's code is dependencies, not code the team wrote itself. DAST (dynamic application security testing) tests a running instance of the application from the outside, the way an attacker would, and so it runs later, typically against a deployed staging environment, after the artifact exists and is running somewhere.
What is the difference between a parameterized query and simply concatenating a sanitized string?
A parameterized query sends the SQL command and the user-supplied values as two separate things to the database driver, the driver (or the database itself, for prepared statements) binds the values into the query plan without ever treating them as part of the SQL text. String concatenation, even "sanitized," still builds one text string where user input and SQL syntax share the same channel, any gap in the sanitization logic can be exploited. Parameterization removes that shared channel entirely rather than trying to police it.
Why does binary search require the input to already be sorted, and what actually happens if you run it on unsorted data?
Binary search's core logic is comparing the target against a midpoint and eliminating the entire half that can't possibly contain it, an elimination step that's only valid if elements are ordered, so everything below the midpoint really is smaller and everything above really is larger. Run it on unsorted data and there's no error or exception, the algorithm has no way to detect the invariant is broken, it just keeps halving the search space based on comparisons that no longer imply anything real, and returns an insertion point or "not found" result that has no actual relationship to whether or where the target exists in the list.
What problem does policy-as-code solve that a manual infrastructure change review does not?
A manual review depends on a human noticing a specific misconfiguration, an open security group, an unencrypted storage bucket, in a plan diff that may span hundreds of resources, and that scrutiny has to be repeated consistently by every reviewer on every change. Policy-as-code encodes the same rule once as executable logic and runs it automatically against every plan, so an overly permissive security group is caught the same way on the hundredth change as the first, without depending on which reviewer happened to be paying attention that day.
A socket shows up in the LISTEN state versus ESTABLISHED. What is actually different about what that socket is doing?
LISTEN means a server-side socket is bound to a port and passively waiting to accept incoming connection requests, it isn't attached to any specific remote peer yet. ESTABLISHED means a full connection has completed its handshake and is actively associated with a specific remote address and port, data can flow in both directions. Seeing a service you expect to be running not show a LISTEN socket on its expected port is usually the very first, most direct signal that the service isn't actually up or isn't bound where you think it is.
A request's input already exceeds the model's context window before generation even starts. What happens, versus a request that only exceeds the limit once output is generated?
If the input alone already exceeds the context window, the API rejects the request upfront with a 400 error, generation never starts at all. If the input fits but input tokens plus the requested max output tokens could exceed the window, current models accept the request and generate as far as they can; if generation actually reaches the window limit before finishing, it stops early with a specific stop reason indicating the context window was exhausted, rather than silently truncating or erroring out mid-response. The distinction matters operationally: the first case is a fixable request-construction bug, the second is a signal to reduce the requested output length or the accumulated conversation history.
Why does wrapping several statements in `BEGIN`/`COMMIT` matter, even for a multi-step operation that's logically one action?
Without an explicit transaction, PostgreSQL commits each statement independently the moment it succeeds; if a multi-step operation (debit one account, credit another) fails halfway through, the database is left in an inconsistent, partially-applied state with no way to undo the completed step. Wrapping the statements in `BEGIN`/`COMMIT` groups them so they can be committed or rolled back together, but that alone isn't automatic protection against every failure mode: PostgreSQL only aborts a transaction on its own when a statement raises an actual SQL error, an `UPDATE` that runs successfully but matches zero rows (a mistyped account id, for instance) is not an error at all, and would otherwise be committed as if the transfer had actually happened. Making the transaction genuinely safe means checking that each `UPDATE` affected exactly the one row expected and issuing an explicit `ROLLBACK` if either check fails, only issuing `COMMIT` once both checks pass.
What does it mean for a secret to be "dynamic" or "short-lived," and why does that reduce risk compared to a long-lived static credential?
A dynamic secret is issued on demand, scoped to a single application instance or session, and expires automatically after a defined lease, a database credential minted when a service starts and revoked automatically when it stops, rather than a password typed in once and left valid indefinitely. If a short-lived secret leaks, its usefulness to an attacker is bounded by its remaining lease time, often minutes, instead of remaining valid until someone notices and manually rotates it. This is the same underlying idea as preferring IAM roles over long-lived access keys in a cloud provider, temporary credentials shrink the blast radius of a leak by construction, not by better hiding the secret.
What is the difference between CloudTrail management events and data events, and why does it matter?
Management events record control-plane operations, creating a role, launching an instance, changing a security group, and every CloudTrail trail logs these by default. Data events record data-plane operations on the resources themselves, an individual S3 GetObject or Lambda Invoke call, and are not logged by default; they have to be explicitly enabled per resource and typically cost extra given their much higher volume. This matters because an investigation into "who read this specific S3 object" will come up completely empty if only the default management events were ever being logged, a genuinely common gap discovered only during an actual incident.
What is the difference between an IAM user and an IAM role?
An IAM user is a long-term identity with its own credentials, a password for console access, or access keys for programmatic access, typically representing a human or a legacy application that needs standing access. An IAM role has no long-term credentials of its own; it is assumed, by a user, an application, or an AWS service, and yields short-lived, automatically-expiring temporary credentials via AWS STS. Roles are the preferred identity for anything running on AWS compute (EC2, Lambda, ECS) precisely because there is no long-lived secret to leak or rotate.
What is the difference between a security group and a network ACL in a VPC?
A security group is stateful and attaches at the instance/ENI level: it only supports allow rules, and if inbound traffic is allowed, the corresponding response traffic is automatically allowed back out regardless of outbound rules. A network ACL is stateless and attaches at the subnet level: it supports both explicit allow and explicit deny rules, numbered and evaluated in order starting from the lowest number, and because it has no memory of prior traffic, allowing inbound traffic does not automatically allow the matching outbound response, that has to be permitted by its own rule. Security groups are the primary, fine-grained access control per resource; network ACLs are a coarser, optional second layer at the subnet boundary.
What is the difference between Blob Storage, File Storage, and Disk Storage in Azure?
Blob Storage is object storage for unstructured data (images, backups, logs), accessed via HTTP/HTTPS APIs, not mounted as a filesystem. File Storage provides fully managed file shares accessible via the SMB or NFS protocol, usable as a network drive that multiple VMs can mount simultaneously. Disk Storage provides block-level storage attached to a single VM, functioning as its virtual hard disk. The choice depends on access pattern: Blob for API-driven unstructured data at scale, File for shared network-drive-style access across machines, Disk for a VM's own persistent local-feeling storage.
What is the difference between time complexity and space complexity?
Time complexity describes how the number of operations grows with input size; space complexity describes how additional memory usage grows with input size. An algorithm can trade one for the other, memoization in dynamic programming typically turns exponential time into polynomial time by spending O(n) or more extra space to cache results.
What is layout thrashing, and why does writing then reading a layout property in a loop specifically cause it?
Layout thrashing happens when code alternates writing a style (which invalidates the current layout) and reading a layout-dependent property like `offsetWidth` (which forces the browser to immediately recalculate layout synchronously to answer that read accurately), repeated across many elements in a loop. Each read-after-write pair forces a fresh, synchronous layout recalculation instead of letting the browser batch and defer that work to its normal rendering schedule, because the code demanded an up-to-date value mid-loop. The fix is mechanical: batch every write first, then batch every read afterward, so layout is only recalculated once instead of once per element.
What is the difference between continuous integration, continuous delivery, and continuous deployment?
Continuous integration means every code change is automatically built and tested against the main branch frequently; the goal is catching integration problems within minutes, not weeks. Continuous delivery extends that so every change that passes CI is automatically packaged into a release-ready artifact, though a human still decides when to actually deploy it. Continuous deployment goes one step further and removes that human gate, every change that passes all automated checks is deployed to production automatically. The three form a spectrum of increasing automation, and most teams stop at continuous delivery rather than full continuous deployment for anything customer-facing.
Why is pipeline speed treated as a first-class metric, not just a convenience?
A slow pipeline directly increases the cost of every mistake, if tests take 40 minutes to run, a developer either waits 40 minutes for feedback or, more likely, starts the next task and context-switches back later, making the eventual failure much more expensive to fix. Fast pipelines keep the feedback loop close to the moment the mistake was introduced, which is when it is cheapest to fix. This is why teams invest in parallelizing test suites, caching dependencies, and running only the checks relevant to what changed, rather than accepting pipeline slowness as a fixed cost.
Why is "rightsizing" usually the highest-leverage cost optimization, and why do teams under-invest in it?
Rightsizing means matching provisioned capacity (instance size, allocated memory) to actual observed usage, and it typically has the biggest impact because most cloud resources are provisioned for a peak or a guess, then never revisited, meaning steady-state waste compounds every hour, every day, indefinitely. Teams under-invest in it because it requires ongoing measurement and periodic action, competing for attention against feature work that has more visible payoff, and because a resource that's "working fine" doesn't generate the same urgency as one that's broken, even if it's costing several times what it needs to.