Search
137 results for “dvavasour”
-
The linked data viewer / dereferencer LDView can now be used without an expensive SPARQL endpoint.
Just convert your RDF data to the hdt format and use that as a datasource. You can even SPARQL them using the integrated Yasgui interface.Above all, LDView attempts to offer a human friendly interface for providing RDF data.
-
The linked data viewer / dereferencer LDView can now be used without an expensive SPARQL endpoint.
Just convert your RDF data to the hdt format and use that as a datasource. You can even SPARQL them using the integrated Yasgui interface.Above all, LDView attempts to offer a human friendly interface for providing RDF data.
-
The linked data viewer / dereferencer LDView can now be used without an expensive SPARQL endpoint.
Just convert your RDF data to the hdt format and use that as a datasource. You can even SPARQL them using the integrated Yasgui interface.Above all, LDView attempts to offer a human friendly interface for providing RDF data.
-
The linked data viewer / dereferencer LDView can now be used without an expensive SPARQL endpoint.
Just convert your RDF data to the hdt format and use that as a datasource. You can even SPARQL them using the integrated Yasgui interface.Above all, LDView attempts to offer a human friendly interface for providing RDF data.
-
The linked data viewer / dereferencer LDView can now be used without an expensive SPARQL endpoint.
Just convert your RDF data to the hdt format and use that as a datasource. You can even SPARQL them using the integrated Yasgui interface.Above all, LDView attempts to offer a human friendly interface for providing RDF data.
-
How Accurate Are Existing Land Cover Maps For Agriculture In Sub-Saharan Africa? [metrics]
--
https://doi.org/10.1038/s41597-024-03306-z <-- shared paper
--
#GIS #spatial #mapping #remotesensing #earthobservation #EO #Africa #SubSaharan #metrics #foodsecurity #agriculture #farming #crops #cropland #landcover #monitoring #quantative #datasources #statistics #geostatistics #accuracy #precision #model #modeling #Kenya #Malawi #Mali #Rwanda #Tanzania #Togo #Uganda #Zambia -
#30DayMapChallenge 2023 #day12 - South America Continuing on looking at the Total fertility rate by country in 2021
DataSource: Wikipedia & {idbr} (Analyzing US Census Data book )
Tool: #R
-
I need some help! I've registered a Grafana Cloud account to monitor one of my servers. I connected the server using the "Monitor your OS" quickstart. It created multiple dashboards all of which seem to be working, but the one called "Linux node / logs". This dashbiard uses a Loki datasource to present some logs. No data is being displayed and non of the dropdows has any values. Now the weird thing is that I cann see logs, via "Explore".
-
New ‘Acme Weather’ app from Dark Sky creators wants to fix weather apps’ biggest problem - 9to5Mac
'The Dark Sky team has launched a new weather app called "Acme Weather" for iPhone, aiming to address forecast uncertainty by offering multiple alternative predictions instead of a single forecast. Inspired by their experience with Dark Sky, which was acquired and shut down by Apple, the app incorporates advanced data sources and features like community reporting and detailed maps. Acme Weather is available for $25 annually with a two-week free trial, and an Android version is planned for the future.'
[Summarised by Apple Intelligence]#DarkSky #WeatherApp #AcmeWeather #iPhoneApp #Forecasts #Predictions #AppleAcquired #DataSources #CommunityReports #DetailedMaps #AnnualSubscription #FreeTrial #AndroidVersion
https://9to5mac.com/2026/02/23/new-weather-app-from-dark-sky-forecasts/
-
The wild fires above the #Elan Valley have spread across into #Ceredigion and are now nearing the forestry above the #Hafod estate near #Cwmystwyth.
Wind is a brisk easterly, so it's not looking good for the forestry.
-
The release of these resources follows several years of community engagement, consultation, and development, but this is just the beginning of the PSDI journey, and we are excited to continue working with the community to expand PSDI.
Please share this with your colleagues and research networks to help us collaborate to accelerate! 🚀🚀
#PSDI #Resources #Community #Engagement #PhysicalSciences #DataInfrastructure #DataSources
-
Lucee in a Box: The Ultimate Guide to Containerized Dev Servers
2,726 words, 14 minutes read time.
The Modern ColdFusion Workspace: Transitioning to Lucee in a Box
The shift from traditional, monolithic server installations to containerized environments has fundamentally altered how we perceive modern development within the Lucee ecosystem. For years, the standard approach involved installing a heavy application server directly onto a local machine, often leading to a “polluted” operating system where various versions of Java and Lucee competed for resources and environment variables. By adopting a “Lucee in a Box” methodology, we decouple the application logic from the underlying hardware, allowing for a portable, reproducible, and lightweight development stack. This transition is not merely about convenience; it is a strategic move toward parity with production environments where high availability and rapid scaling are the norms. In this architecture, we utilize Docker to encapsulate the Lucee engine, the web server, and the necessary configuration files into a single unit that can be spun up or destroyed in seconds, ensuring that every member of a development team is working within an identical, script-driven environment.
However, the true complexity of this setup emerges when we move beyond simple “Hello World” examples and begin integrating with the existing corporate infrastructure. In my own workflow, I rely heavily on a network of internal web services that act as the primary conduit for data residing in our production databases. These services are vital because they provide a sanitized, governed layer of abstraction over raw SQL queries, ensuring that sensitive data is handled according to internal compliance standards. When we containerize Lucee, we aren’t just running a script; we are placing a small, isolated node into a complex network. The challenge then becomes ensuring this isolated container can “see” and communicate with those internal services as if it were a native part of the network, all while maintaining the security boundaries that containerization is designed to provide.
The Data Silo Crisis: Overcoming Networked Service Isolation
One of the most significant hurdles in modernizing a CFML stack is the inherent isolation of the Docker bridge network, which often creates what I call a “Data Silo” during local development. When a developer attempts to call an internal web service—perhaps a REST API that fetches real-time production metrics or user permissions—from within a container, the request often hits a wall because the container’s internal DNS does not naturally resolve local intranet addresses. This creates a frustrating disconnect where the application works perfectly in the legacy local install but fails within the containerized environment. This disconnect is more than a minor annoyance; it leads to significant delays in the development lifecycle as engineers struggle to pipe in the data necessary for testing complex business logic. Without a seamless connection to these internal services, the “Lucee in a Box” becomes an empty vessel, incapable of performing the data-intensive tasks required in a modern enterprise setting.
To resolve this, we must look at how the container perceives the outside world and how the host machine facilitates that visibility. In many corporate environments, production data is guarded behind strict firewall rules and SSL requirements that expect requests to originate from known entities. When I utilize internal web services to provide data from a production database, the Lucee container must be configured to pass through the host’s network or be explicitly granted access to the internal DNS suffixes. Failure to address this at the architectural level results in “unreachable host” errors or SSL handshake failures that can derail a project for days. By understanding that the container is a guest on your network, we can begin to implement the routing and trust certificates necessary to turn that siloed container into a fully integrated node capable of consuming live data streams securely and efficiently through modern CFScript syntax.
The Blueprint: Implementing Lucee and MariaDB via Docker Compose
To move from theory to implementation, we must define the orchestration layer that brings our environment to life. The
docker-compose.ymlfile is the definitive source of truth for the development stack, eliminating the “it works on my machine” excuse by codifying the server version, database configuration, and network paths. In the professional workflow I advocate, this file sits at the root of your project. It defines aluceeservice using the official Lucee image—optimized for performance—and amariadbservice to handle local data persistence. Crucially, we use volumes to map your localwwwfolder directly into the container’s web root. This means that as you write your CFScript in your preferred IDE on your host machine, the changes are reflected instantly inside the container without requiring a rebuild or a manual file transfer.The following configuration provides a professional-grade starting point. It establishes a dedicated network for our services and ensures that Lucee has the environment variables necessary to eventually automate its datasource connections. By mounting the
./wwwdirectory, we ensure our code remains on our host machine where it can be version-controlled, while the./db_datavolume ensures our MariaDB data persists even if the container is destroyed and recreated.version: '3.8' services: # The Database Engine mariadb: image: mariadb:10.6 container_name: lucee_db restart: always environment: MYSQL_ROOT_PASSWORD: root_password MYSQL_DATABASE: dev_db MYSQL_USER: dev_user MYSQL_PASSWORD: dev_password volumes: - ./db_data:/var/lib/mysql networks: - dev_network # The Lucee Application Server lucee: image: lucee/lucee:5.3 container_name: lucee_app restart: always ports: - "8080:8888" environment: # Injecting DB credentials for CFConfig or Application.cfc - DB_HOST=mariadb - DB_NAME=dev_db - DB_USER=dev_user - DB_PASSWORD=dev_password - LUCEE_ADMIN_PASSWORD=server_admin_pass volumes: - ./www:/var/www - ./config:/opt/lucee/web depends_on: - mariadb networks: - dev_network networks: dev_network: driver: bridgeDeployment Strategy: Running Your New Containerized Stack
Once the
docker-compose.ymlfile is in place, initializing the environment is a matter of a single terminal command. By executingdocker-compose up -dfrom the root of your project directory, the Docker engine pulls the specified images, creates the isolated virtual network, and establishes the volume mounts. This process ensures that your MariaDB instance is ready to receive connections before the Lucee server fully initializes. For developers who rely on internal web services, this is where the containerized approach proves its worth. Because Lucee is running in an isolated network but can be configured to have access to the host’s bridge or external DNS, it can safely consume external APIs while maintaining a clean, local database for session state or cached production data. This setup provides the exact same architectural “feel” as a high-traffic production cluster, but contained entirely within your local hardware.The beauty of this system lies in its maintenance-free nature and the elimination of the “dependency hell” that often plagues legacy ColdFusion developers. If you need to test your CFScript against a different version of Lucee or a newer patch of MariaDB, you simply update the version tag in the YAML file and run the command again. There is no need to uninstall software, clear registry keys, or worry about Java version conflicts on your host machine. This modularity is why I utilize internal web services to provide data from production into this local box; the container acts as a secure, high-speed proxy. You can pull the data you need via an internal API call, store it in the MariaDB container, and work in an isolated state without ever risking the integrity of the actual production database.
Root Cause: Why Standard Containers Fail at Internal Service Integration
The primary reason most off-the-shelf Lucee container configurations fail when attempting to consume internal web services is a fundamental lack of trust—specifically, the absence of internal SSL certificates within the Java KeyStore. When I use web services hosted within my network to provide data from a production database, those services are almost always secured via an internal Certificate Authority (CA) that is not recognized by the default OpenJDK installation inside the Lucee container. This results in the dreaded “PKIX path building failed” error the moment a
cfhttpcall is initiated via CFScript to an internal endpoint. To solve this, the Dockerfile must be modified to perform a “copy and import” operation during the image build phase, where the internal CA certificate is added to the Java security folder and registered using thekeytoolutility. This ensures that the underlying Java Virtual Machine (JVM) trusts the internal network’s identity, allowing for encrypted, secure data transmission from the production-proxy services to the local development environment.Beyond the cryptographic hurdles, there is the issue of routing and “Host-to-Container” communication that often stymies developers new to the Docker ecosystem. In a standard Docker setup, the container is wrapped in a layer of Network Address Translation (NAT) that makes it difficult to reach services sitting on the developer’s physical host or the wider corporate VPN. To bridge this gap, we often utilize the
extra_hostsparameter within ourdocker-composeconfiguration, which effectively injects entries into the container’s/etc/hostsfile. This allows us to map a friendly internal domain name, likeservices.internal.corp, directly to the IP address of the host machine or the VPN gateway. By explicitly defining these routes, we bypass the limitations of Docker’s isolated bridge and enable the Lucee engine to reach out to the web services that house our production data. This architectural “handshake” between the containerized Lucee instance and the physical network is the secret sauce that transforms a basic dev box into a high-fidelity replica of the production ecosystem.Deep Dive: Consuming Internal Web Services via CFScript
With the network and security infrastructure in place, we can finally focus on the implementation layer: the CFScript that handles the data exchange. In a modern Lucee in a Box setup, I favor a service-oriented architecture where a dedicated
DataService.cfchandles all interactions with the internal network. Using thehttpservice in CFScript, we can construct requests that include the necessary authentication headers, such as JWT tokens or API keys, required by the internal production data services. The beauty of this approach is that the CFScript remains agnostic of the container’s physical location; as long as the Docker networking layer is correctly mapping the service URL to the internal network, thecfhttpcall proceeds as if it were running on a native server. This allows us to maintain a clean, readable codebase that utilizes the latest CFScript features, such ascfhttp(url=targetURL, method="GET", result="local.apiResponse"), while the heavy lifting of network routing is handled by the Docker daemon.The real power of this integration is realized when we use these internal web services to populate our local MariaDB instance with a “snapshot” of production-like data. Rather than dealing with massive, cumbersome database dumps that can compromise data privacy, we can write an initialization script in CFScript that queries the internal web services for the specific datasets required for a given task. This script can then parse the returned JSON and perform a series of
queryExecute()commands to populate the local MariaDB container. This “just-in-time” data strategy ensures that the developer is always working with relevant, fresh data without the security risks associated with a direct connection to the production database. By leveraging the containerized Lucee instance as a smart bridge between internal network services and local storage, we create a development environment that is not only isolated and secure but also incredibly data-rich and performant.Environment Variable Injection: The CFConfig and CommandBox Synergy
To achieve a truly “hands-off” configuration within a Lucee in a Box environment, we must move away from the manual web-based administrator and toward a purely scripted setup. This is where the combination of CommandBox and the CFConfig module becomes indispensable. By using a
.cfconfig.jsonfile or environment variables prefixed withLUCEE_, we can define our MariaDB datasource connections, internal web service endpoints, and mail server settings without ever clicking a button in the Lucee UI. In a professional workflow, this means thedocker-compose.ymlfile serves as the master controller, injecting credentials and network paths directly into the Lucee engine at runtime. For instance, by settingLUCEE_DATASOURCE_MYDBas an environment variable, the containerized engine automatically constructs the connection to the MariaDB container, ensuring that our CFScript-basedqueryExecute()calls have a reliable target the moment the server is healthy.This approach is particularly powerful when dealing with the internal web services that provide our production data. Since these services often require specific API keys or internal proxy settings, we can store these sensitive values in an
.envfile that is excluded from our Git repository. When the container starts, these values are mapped into the Lucee process, allowing our CFScript logic to access them viasystem.getEnv(). This ensures that our local development environment remains a mirror of our production logic while maintaining a strict separation of concerns between the application code and the infrastructure-specific secrets. By automating the configuration layer, we eliminate the risk of manual setup errors and ensure that every developer on the team can spin up a fully functional, networked-aware Lucee instance in a single command.Advanced Networking: Bridged Access to Production-Proxy Services
The final piece of the Lucee in a Box puzzle involves fine-tuning the Docker network to handle the high-latency or high-security requirements of internal web services. When our CFScript makes a request to a service that pulls from a production database, we are often traversing multiple layers of internal routing, including VPNs and load balancers. To optimize this, we can configure our Docker bridge network to use specific MTU (Maximum Transmission Unit) settings that match our corporate network’s infrastructure, preventing packet fragmentation that can lead to mysterious request timeouts. Furthermore, by utilizing Docker’s
aliaseswithin the network configuration, we can simulate the production URL structure locally. This means our CFScript can callhttps://api.internal.production/both in the dev container and the live environment, with Docker handling the redirection to the appropriate internal service endpoint based on the environment context.Beyond simple connectivity, we must also consider the performance of these data-heavy web service calls. In a containerized environment, I often implement a caching layer within Lucee that stores the JSON payloads returned from our internal services into the local MariaDB instance or a RAM-based cache. By using CFScript’s
cachePut()andcacheGet()functions, we can significantly reduce the load on our internal network and the production database proxy. This “lazy-loading” strategy allows us to develop complex features with the speed of local data access while still maintaining the accuracy of production-sourced information. This architectural decision—balancing live service integration with local persistence—represents the pinnacle of the Lucee in a Box philosophy, providing a development experience that is as fast as it is faithful to the real-world environment.Conclusion: The Future of Scalable CFML Development
Adopting a “Lucee in a Box” strategy is more than just a trend in containerization; it is a fundamental shift toward professional-grade, reproducible engineering. By strictly defining our environment through
docker-compose.yml, automating our security through SSL injection in the Dockerfile, and utilizing CFScript to bridge the gap between internal web services and local MariaDB storage, we create a stack that is resilient to “configuration drift.” This setup allows us to treat our development servers as ephemeral, disposable assets that can be rebuilt at a moment’s notice to match evolving production requirements. As the Lucee ecosystem continues to mature, the ability to orchestrate these complex data flows within a containerized boundary will remain the hallmark of a high-performing development team, ensuring that we spend less time debugging infrastructure and more time writing the logic that drives our applications forward.Call to Action
If this post sparked your creativity, don’t just scroll past. Join the community of makers and tinkerers—people turning ideas into reality with 3D printing. Subscribe for more 3D printing guides and projects, drop a comment sharing what you’re printing, or reach out and tell me about your latest project. Let’s build together.D. Bryan King
Sources
- Lucee Official Documentation: Lucee Docker Images
- Ortus Solutions: CommandBox Docker Documentation
- NIST SP 800-190: Application Container Security Guide
- Docker Documentation: Bridge Network Driver and Architecture
- IANA: Service Name and Transport Protocol Port Number Registry
- MITRE CWE-601: URL Redirection to Untrusted Site (Internal Service Security)
- Docker Engine: Dockerfile Reference and Best Practices
- CFConfig: Environment Variable Integration for Lucee
- CIS Benchmarks: Docker Community Edition Benchmark
- IETF RFC 7519: JSON Web Token (JWT) for Internal Service Auth
- Wireshark User Guide: Analyzing Internal Network Traffic
- Oracle Java SE Security: Standard Algorithm Names (TLS Support for Lucee)
Disclaimer:
The views and opinions expressed in this post are solely those of the author. The information provided is based on personal research, experience, and understanding of the subject matter at the time of writing. Readers should consult relevant experts or authorities for specific guidance related to their unique situations.
Related Posts
Rate this:
#APIAuthentication #Automation #backendDevelopment #BridgeNetwork #cacerts #CFConfig #CFML #cfScript #CICD #CloudNative #Coldfusion #CommandBox #ConfigurationDrift #containerization #DataIntegration #DatabaseMigration #DatabaseProxy #DeepDive #deployment #devops #Docker #DockerCompose #EnterpriseDevelopment #environmentVariables #InfrastructureAsCode #InternalAPIs #ITInfrastructure #JavaKeyStore #JSON #JVM #JWT #localDevelopment #Lucee #LuceeInABox #MariaDB #microservices #Networking #OpenJDK #OrtusSolutions #Persistence #PortForwarding #Portability #ProductionData #ReproducibleEnvironments #RESTAPI #scalability #Scripting #SDLC #SecureDevelopment #softwareArchitecture #SQL #SSLCertificates #TechnicalGuide #Volumes #WebApplication #WebServer #WebServices #WorkflowOptimization -
A Paris Airport Thermometer Just Exposed Crypto’s Oldest Unsolved Problem
A suspected manipulation of weather data tied to a prediction market payout has renewed scrutiny around the “oracle…
#France #FR #Europe #EU #Paris #AakashGupta #CharlesdeGaulleAirport #datasource #LeBourgetAirport #MétéoFrance #oracleproblem #Polymarket #temperaturesensor
https://www.europesays.com/france/8563/ -
DBeaver 24.2.3 released
Supports any database which has JDBC driver (which basically means - ANY database). Commercial versions also support non-JDBC datasources such as MongoDB, Cassandra, Couchbase, Redis, BigTable, ScyllaDB, DynamoDB, etc.
-
RE: https://mastodon.social/@arstechnica/116518027082154811
This technique is commonly used for insider detection. Plant a unique canary in a datasource someone has access to and see which canary shows up and you have the leaker.
Another technique inverted to this purpose to spot manipulation without using obvious hashes or digital signatures is to insert a specific message into a plaintext that may be formatted wrong or not comply with the uniformity then get a HMAC signature out of it. Loop through the data and check if the MAC is created. This is called Chaffing and Winnowing:
https://en.wikipedia.org/wiki/Chaffing_and_winnowing#cryptography #insiderdetection #espionage #dataintegrity #manipulation
-
Insights with Vishal Khera @insightswithvishalkhera.wordpress.com@insightswithvishalkhera.wordpress.com ·SITECORE EXPERIENCE EDGE 429 RATE LIMITS: Patterns That Actually Work in Production
INTRODUCTION
Across the projects I’ve worked on, this little log line shows up sooner or later on almost every XM Cloud build:
HTTP 429 Too Many Requests X-Rate-Limit-Limit: 80Experience Edge ships with a fair-use guardrail of 80 uncached requests per second per tenant — a deliberate design choice that keeps multi-tenant Edge fast for everyone. Apps that respect this guardrail run beautifully. Apps that don’t can see ISR revalidations queue up and Vercel logs grow noisy during traffic surges. The good news: the patterns to stay well under it are well-established.
This blog is the playbook I give every team when they hit this. Five patterns that actually work, with the exact code and configuration needed to ship them. Every pattern below is verified against the Sitecore Accelerate Cookbook and the official Experience Edge documentation.
The Bit Most Teams Miss
The Sitecore docs explain the 80 req/sec number plainly. What they don’t tell you is how that number actually behaves in real projects, which is what trips teams up. Three things I’ve learned to remind every team I work with:
- It is per tenant, not per page or per user. So a single popular page can soak the whole budget.
- It only counts uncached requests. The whole game is making sure as many of yours as possible are cached.
- The window resets every second. That means a burst of 200 calls in one second is far worse than 200 calls spread over five seconds. Steady throughput beats bursty traffic on this platform every time.
Where my clients have hit this in practice:
- A popular page revalidates during a traffic surge, taking 50+ concurrent GraphQL calls with it.
- Wildcard routes (product details, article pages) fan out at build or during ISR.
- A sitemap with 10,000 URLs tries to refresh all at once.
With that context, here are the patterns.
Pattern 1: Start With SSG, Not SSR
If I have time for one conversation with a team about Edge cost, this is it. SSR is the single biggest reason teams burn through their request budget. Every request hits Edge afresh, no matter how identical the page output. SSG flips the script: render once, serve from cache until revalidation fires.
If your XM Cloud Next.js app is still using
getServerSidePropsor unconfigured route handlers, move to SSG first. Everything else in this playbook compounds on top of it.// Content SDK - App Router SSG with revalidation // app/[[...path]]/page.tsx import { sitecoreClient } from 'lib/sitecore-client'; export const revalidate = 3600; export async function generateStaticParams() { const sitemap = await sitecoreClient.getSiteMap(); return sitemap.map((entry) => ({ path: entry.path.split('/').filter(Boolean), })); } export default async function Page({ params }) { const route = await sitecoreClient.getRouteData({ path: '/' + (params.path?.join('/') ?? ''), language: 'en', }); return ; }Gotcha: generateStaticParams called against a 10k-entry sitemap at build time is itself a burst of Edge calls. Run your first build against a limited sitemap in a preview deployment before flipping production.
Pattern 2: Consolidate Queries with GraphQL Aliases
Walk through your component tree and count the GraphQL fetches a single page makes. On most projects I audit, the answer is somewhere between five and twelve, just for the chrome (header, footer, nav, search, meta, breadcrumbs). Each of those counts as a separate request against your budget.
GraphQL aliases let you merge them into a single request. This pattern is in the Sitecore Accelerate Cookbook for a reason.
Before – five queries, five requests:
query GetHeader($path: String!) { item(path: $path) { ... } } query GetFooter($path: String!) { item(path: $path) { ... } } query GetNav($path: String!) { item(path: $path) { ... } } query GetSearch($path: String!) { item(path: $path) { ... } } query GetMeta($path: String!) { item(path: $path) { ... } }After – one query with aliases, one request:
query GetPageGlobals( $headerPath: String! $footerPath: String! $navPath: String! $searchPath: String! $metaPath: String! ) { header: item(path: $headerPath) { ...HeaderFields } footer: item(path: $footerPath) { ...FooterFields } nav: item(path: $navPath) { ...NavFields } search: item(path: $searchPath) { ...SearchFields } meta: item(path: $metaPath) { ...MetaFields } } fragment HeaderFields on Item { id name fields { name value } } fragment FooterFields on Item { id name fields { name value } }Five separate fetches become one fetch. On a 50-component page, this alone can reduce your Edge calls by 70-80%.
Pattern 3: Use Vercel Data Cache with fetch + revalidate + Tags
If I had to pick the one pattern that has saved my projects the most Edge calls, this is it. Vercel’s Data Cache sits between your app and Experience Edge by default when you deploy XM Cloud there. The opportunity is what most teams miss: with the right
revalidateandtagson every fetch, the same GraphQL call gets served from cache across thousands of page renders. You go from “every request hits Edge” to “the first request hits Edge, the next 9,999 don’t.”// lib/fetch-edge.ts - wrap raw Edge calls through this helper. // For most data fetching in Content SDK apps, prefer the built-in // SitecoreClient methods (getRouteData, getSiteMap, etc.) since they // handle auth, retries, and caching for you. export async function fetchEdge(args) { const res = await fetch(process.env.SITECORE_EDGE_URL, { method: 'POST', headers: { 'content-type': 'application/json', // sc_apikey expects your Edge Delivery API key, not the Context ID. 'sc_apikey': process.env.SITECORE_EDGE_API_KEY, }, body: JSON.stringify({ query: args.query, variables: args.variables }), next: { revalidate: args.revalidate ?? 3600, tags: args.tags ?? [], }, }); if (!res.ok) throw new Error('Edge error ' + res.status); const json = await res.json(); return json.data; }Heads up: sc_apikey and the Content SDK CONTEXT_ID are two different auth mechanisms. The context ID is how the SDK finds your Edge environment and resolves credentials internally. The sc_apikey is the explicit Delivery API key you generate yourself. Keep them separate in your env vars.
Usage – tag fetches so you can invalidate them surgically:
const nav = await fetchEdge({ query: NAV_QUERY, variables: { path: '/sitecore/content/site/navigation' }, revalidate: 86400, tags: ['nav', 'globals'], }); const news = await fetchEdge({ query: NEWS_QUERY, revalidate: 300, tags: ['news'], });Now every component that needs navigation hits the cache on subsequent renders. Your Edge call count drops dramatically.
Pattern 4: Revalidate Tags on Publish via Webhook
Now we hit the question every editor will ask within a week of go-live: if I cache navigation for 24 hours, why aren’t my published changes showing up?
Answer: hook the Sitecore publish event to a Next.js revalidation route. This is one of the under-appreciated parts of XM Cloud’s webhook system. You can react to publishes, items being saved, almost anything.
// app/api/revalidate/route.ts import { revalidateTag } from 'next/cache'; import { NextResponse } from 'next/server'; export async function POST(request) { const secret = request.headers.get('x-revalidate-secret'); if (secret !== process.env.REVALIDATE_SECRET) { return NextResponse.json({ ok: false }, { status: 401 }); } let body; try { body = await request.json(); } catch { return NextResponse.json({ ok: false }, { status: 400 }); } const tags = mapPayloadToTags(body); for (const tag of tags) revalidateTag(tag); return NextResponse.json({ ok: true, tags }); } function mapPayloadToTags(payload) { return ['globals']; }Create a Webhook Event Handler in Sitecore at
/sitecore/system/Settings/Webhooks/pointing at/api/revalidate. When content publishes, the webhook fires, the matching tags invalidate, and the next visitor gets fresh content without you paying the Edge bill for everyone else.Heads up: Set the secret header on both sides or your endpoint becomes a public cache-buster. I have seen this in production.
Pattern 5: Tune the Retry Strategy in sitecore.config.ts
Even with all the caching above, some requests will miss. Content SDK gives you a clean way to handle that gracefully. The older GRAPH_QL_SERVICE_RETRIES environment variable from JSS days is gone, replaced by a config-based retry strategy that lives in
sitecore.config.ts. I prefer this because it’s versioned with the code, not buried in environment variables nobody reviews.Simple form – just a retry count:
// sitecore.config.ts import { defineConfig } from '@sitecore-content-sdk/nextjs/config'; export default defineConfig({ api: { edge: { contextId: process.env.CONTEXT_ID, edgeUrl: process.env.SITECORE_EDGE_URL, }, }, retries: 3, defaultSite: 'my-site', defaultLanguage: 'en', });Advanced form – custom status codes and back-off factor:
// sitecore.config.ts import { defineConfig } from '@sitecore-content-sdk/nextjs/config'; import { DefaultRetryStrategy } from '@sitecore-content-sdk/core'; export default defineConfig({ api: { edge: { contextId: process.env.CONTEXT_ID, edgeUrl: process.env.SITECORE_EDGE_URL, }, }, retryStrategy: new DefaultRetryStrategy({ statusCodes: [429, 502, 503, 504], factor: 2, }), defaultSite: 'my-site', defaultLanguage: 'en', });A three-retry exponential strategy recovers from transient 429s in the vast majority of cases. Anything more than 3 retries is usually a sign you should be fixing cache patterns, not backing off harder.
Pattern 6: Wildcard Pages for High-Fanout Routes
This one is a content-modelling decision more than a code one, and it’s where I’ve seen teams gain the most ground without writing a line of new code. For routes with thousands of URLs that all share the same layout (product detail, article, knowledge base), use a wildcard page. The layout response caches against the wildcard item once, and every concrete URL reuses that cached layout.
- Wildcard layout calls: cached against the wildcard item, free after the first hit
- Concrete item data: still fetched per URL, but at the datasource level, not the full layout
The net effect is that a site with 10,000 product pages uses roughly the same Edge budget as a site with 100.
Pitfalls I See on Almost Every Project
Pitfall 1: Forgetting to Tag Fetches
I have lost count of how many code reviews I’ve done where the fetchEdge helper is in place but every call has an empty tags array. Then a publish event comes in and the team has two bad options: nuke the entire cache (slow, costly) or let stale content sit for hours. Neither is good.
The fix: Tag every fetch. Even [‘global’] on a catch-all is better than nothing.
Pitfall 2: Using the Same TTL for Everything
I see this on roughly half the projects I audit: a single revalidate: 3600 everywhere. News content goes stale. The home page churns refreshes for content that hasn’t actually changed. Both costs are paid for the same TTL.
The fix: Match TTL to actual publishing cadence per content type. Nav: 24 hours. News: 5 minutes. Marketing copy: 1 hour.
Pitfall 3: Not Monitoring 429 Response Rates
The earliest signal that you are approaching the guardrail is 429 responses in your logs. Telemetry catches this well before users do. The X-Rate-Limit-Limit: 80 header confirms the limit on every response, so you can wire it into a dashboard from day one.
The fix: Instrument your Edge fetch wrapper to count responses by status code. Log every 429 with timestamp, route, and query name. Set a dashboard alert on any sustained 429 rate above zero in the last 15 minutes.
Pitfall 4: Treating revalidate as a Magic Number
When I ask a team why they chose revalidate: 3600, the honest answer is usually “that’s what the starter had.” That’s not a decision, it’s a default. Each data type deserves a TTL chosen on the basis of how fresh it actually needs to feel and how expensive a cache miss is.
The fix: Document the TTL decision per content type in your README or sitecore.config.ts comments. Review it every quarter as publishing cadence changes.
Key Takeaways
✓ The fair-use guardrail is 80 uncached GraphQL requests per second per tenant. Know this number and design for it from day one.
✓ SSG first. SSR hits Edge on every request. SSG + revalidation is the default for a reason.
✓ Consolidate queries with GraphQL aliases. Five queries become one. Do this everywhere it makes sense.
✓ Vercel Data Cache is your best friend. Wrap every Edge call through a fetchEdge helper with revalidate and tags, or use the Content SDK built-ins where you can.
✓ Invalidate via webhook on publish, not by shortening TTL. Longer TTLs + on-publish invalidation beats short TTLs every time.
✓ Use DefaultRetryStrategy with exponential back-off. Three retries covers most transient 429s. More than that means your cache strategy needs work.
✓ Wildcard pages for high-fanout routes. 10,000 product pages can share one layout cache entry.
✓ Instrument 429 rate monitoring. Count and alert on 429 responses in your Edge fetch wrapper so you catch issues before users do.
#saas #sitecore #SitecoreXMCloud #xmCloudA 429 in production is rarely an Experience Edge problem. It is almost always a caching-strategy problem.
-
After quite some time, I finally have all the pieces in place. Over the last 30 minutes, I’ve set up one of my servers from scratch. Here are some key changes:
- Reverse Proxy: Nginx with Modsecurity (WAF)
- Container Isolation: Every container runs in a seperate linux user
- Podman Quadlet: I rewrote all my compose stacks into quadlet files - now all containers are starting probably after reboot 🥳
- Grafana: Grafana's configuration is no managed by Opentofu which provitions at the moment the datasources (Grafana Loki and Prometheus) as well as the dashboards.
- Server hardening: Improved ssh configuration, firewall, permissions in general on this host
- Ansible: Everything is powered by ansible
- Certbot: Use wildcard certificates for my domains / subdomains for easier renew process
- Backups: All those services have proper backups configured which are timed with systemd timer and are replicated into my local homelab.
- Services that are running at the moment
- Grafana
- Prometheus
- Grafana Loki
- Grafana Alloy
- GitLab Runner
- some other services that I wanna migrate to this server#homelab #sysadmin #linux #ansible #automation #devsecops #selfhosting #declarative #gitops #monitoring
-
Education Lies Beneath the Clouds of Earth Observation
--
https://eos.org/editor-highlights/education-lies-beneath-the-clouds-of-earth-observation <-- shared technical article
--
https://doi.org/10.1029/2023AV000894 <-- shared paper
--
#GIS #spatial #mapping #gischat #remotesensing #satellite #earthobservation #cloudcomputing #cloudstorage #education #EO #learning #teachingmethods #opensource #ethics #public #geoethics #stakeholders #social #cultural #environmental #publichealth #climatechange #usecases #appliedscience #global #changes #earth #datasources #opendata #usercommunity #students #scientists #educators #researchers #contributions -
At last week's #Observability TAG meeting, we discussed a proposal for a unified UI within
@OpenSearchProject Dashboards that displays alerts from @Prometheus #Alertmanager and #OpenSearch Alerting side-by-side. Check out the RFC and chime in with your thought:
https://github.com/opensearch-project/alerting/issues/2026This follows the added support for #Prometheus datasource, so you can already query and explore those #metrics in #OpenSearch Dashboards (with PromQL) alongside your logs and traces.
-
Jeśli instalujecie #DIY #LTE z anteną zewnętrzną kierunkową (tzw. #ODU lub antena na kablu, lub 2 kablach) to może wam się przydać mapa i wyszukiwarka #BTS (czyli stacji bazowych operatorów #GSM, masztów).
Ja skorzystałem z #BTSearch:
Kompas w telefonie pozwala ustawić kierunek "zgrubnie", warto później sprawdzić wskazania poziomu sygnału w routerze/modemie by "dopieścić" ustawienie kierunku.
W zależności od przeszkód terenowych, nie zawsze najbliższy BTS obsłuży wasz modem najlepiej. Warto pokombinować. Również raz ustawiony może z czasem stać się nieoptymalnym, np. przez zwiększenie ilości urządzeń abonenckich. Warto wtedy pokombinować z innymi dostępnymi. Podobnie operatorzy oferują w danej lokalizacji różną jakość. Warto dobrać odpowiedniego.
To jest radio, nie kabel, tu bywa różnie 😉
-
The #GeoNames geographical database covers all countries and is powered by #OpenData https://www.geonames.org/datasources/
-
https://unherd.com/2022/11/how-britain-became-an-american-colony/
What do we think? Has social media made us so Americanised that we don't even notice? Am I the only person left who winces at "leverage" used as a verb with a short E?
Closer to home, does the fediverse feel more culturally diverse than birdsite? Is this as important as being free of Space Karen?
#unherd #Americanisation #leverage #51stState #fediverse #birdsite #SpaceKaren
-
🎉Part 4: Building a Fullstack App with #dart_frog and u/FlutterDev in a Monorepo is now LIVE🚀!
🛠 Implement r/PostgreSQL db, added r/laravel -inspired HTTPController, fully implement CRUD, datasource, repository. https://saileshdahal.com.np/building-a-fullstack-app-with-dartfrog-and-flutter-in-a-monorepo-part-3
#fullstack #monorepo #todoapp #flutter
submitted by /u/saileshbro
[link] [comment…https://www.reddit.com/r/FlutterDev/comments/1016smg/part_4_building_a_fullstack_app_with_dart_frog/
-
@andy Are you saying you know better than the Science Minister? Me too. #bandwaggon #wankwordBingo
-
New ‘Acme Weather’ app from Dark Sky creators wants to fix weather apps’ biggest problem - 9to5Mac
'The Dark Sky team has launched a new weather app called "Acme Weather" for iPhone, aiming to address forecast uncertainty by offering multiple alternative predictions instead of a single forecast. Inspired by their experience with Dark Sky, which was acquired and shut down by Apple, the app incorporates advanced data sources and features like community reporting and detailed maps. Acme Weather is available for $25 annually with a two-week free trial, and an Android version is planned for the future.'
[Summarised by Apple Intelligence]#DarkSky #WeatherApp #AcmeWeather #iPhoneApp #Forecasts #Predictions #AppleAcquired #DataSources #CommunityReports #DetailedMaps #AnnualSubscription #FreeTrial #AndroidVersion
https://9to5mac.com/2026/02/23/new-weather-app-from-dark-sky-forecasts/
-
New ‘Acme Weather’ app from Dark Sky creators wants to fix weather apps’ biggest problem - 9to5Mac
'The Dark Sky team has launched a new weather app called "Acme Weather" for iPhone, aiming to address forecast uncertainty by offering multiple alternative predictions instead of a single forecast. Inspired by their experience with Dark Sky, which was acquired and shut down by Apple, the app incorporates advanced data sources and features like community reporting and detailed maps. Acme Weather is available for $25 annually with a two-week free trial, and an Android version is planned for the future.'
[Summarised by Apple Intelligence]#DarkSky #WeatherApp #AcmeWeather #iPhoneApp #Forecasts #Predictions #AppleAcquired #DataSources #CommunityReports #DetailedMaps #AnnualSubscription #FreeTrial #AndroidVersion
https://9to5mac.com/2026/02/23/new-weather-app-from-dark-sky-forecasts/
-
New ‘Acme Weather’ app from Dark Sky creators wants to fix weather apps’ biggest problem - 9to5Mac
'The Dark Sky team has launched a new weather app called "Acme Weather" for iPhone, aiming to address forecast uncertainty by offering multiple alternative predictions instead of a single forecast. Inspired by their experience with Dark Sky, which was acquired and shut down by Apple, the app incorporates advanced data sources and features like community reporting and detailed maps. Acme Weather is available for $25 annually with a two-week free trial, and an Android version is planned for the future.'
[Summarised by Apple Intelligence]#DarkSky #WeatherApp #AcmeWeather #iPhoneApp #Forecasts #Predictions #AppleAcquired #DataSources #CommunityReports #DetailedMaps #AnnualSubscription #FreeTrial #AndroidVersion
https://9to5mac.com/2026/02/23/new-weather-app-from-dark-sky-forecasts/
-
🧐 Many of you may not know this, but Epieos is available in 3️⃣ versions:
1️⃣ #Free Version
🧑💻 Allows you to verify whether an #email address exists and check if it appears on around ten websites.
2️⃣ #Commercial Version (Public Access)
👨💼 Open to everyone, this version provides detailed information mainly about #email addresses, along with limited insights on #phone numbers. It queries approximately 200 #datasources to deliver relevant results.
3️⃣ #Private Version (Trusted Organizations)
🕵️♂️ Designed for law enforcement, governments and trusted organizations, it enables in-depth #investigations of emails and phone numbers by scanning over 550 websites and social networks that may be linked to your query.
📮 If you'd like to learn more, feel free to comment this post or contact us at contact[at]epieos[.]com.
-
🧐 Many of you may not know this, but Epieos is available in 3️⃣ versions:
1️⃣ #Free Version
🧑💻 Allows you to verify whether an #email address exists and check if it appears on around ten websites.
2️⃣ #Commercial Version (Public Access)
👨💼 Open to everyone, this version provides detailed information mainly about #email addresses, along with limited insights on #phone numbers. It queries approximately 200 #datasources to deliver relevant results.
3️⃣ #Private Version (Trusted Organizations)
🕵️♂️ Designed for law enforcement, governments and trusted organizations, it enables in-depth #investigations of emails and phone numbers by scanning over 550 websites and social networks that may be linked to your query.
📮 If you'd like to learn more, feel free to comment this post or contact us at contact[at]epieos[.]com.
