#nss

The Solid Project and the Semantic Web: A Journey Towards a Decentralized Future

/ configedit / Leave a comment

Introduction

The internet has revolutionized how we access information, communicate, and conduct business. However, as the web has matured, concerns about data privacy, ownership, and the centralization of power have grown. The Solid project, championed by World Wide Web inventor Sir Tim Berners-Lee, offers a radical vision for a decentralized web, empowering individuals to control their data. This article explores the history of the web, the genesis of Solid, its current status, and the transformative possibilities it presents, including the intriguing prospect of “AI Charlie” and its implications for a more semantic and user-centric internet.

The History of the Web: From Hyperlinks to Centralization

The World Wide Web began as a simple system of interconnected documents, built on principles of openness and decentralization. Its early days were characterized by static HTML pages and a spirit of collaborative innovation.

Web 1.0: The Read-Only Web (1990s)

In its nascent stage, the web was primarily a medium for consuming information. Websites were largely static, and user interaction was limited to clicking hyperlinks and viewing content. This era laid the foundation for the information age, making vast amounts of data accessible to a global audience.

Web 2.0: The Social Web (Early 2000s – Present)

The advent of Web 2.0 marked a significant shift towards user-generated content and interactive platforms. Social media, blogs, wikis, and online communities transformed the web into a dynamic space where users could not only consume but also create and share information. Companies like Facebook, Google, and Amazon rose to prominence by building centralized platforms that aggregated user data, offering convenient services in exchange for personal information. This era, while immensely beneficial in fostering global connectivity, also brought about concerns regarding data privacy, algorithmic manipulation, and the immense power wielded by a few tech giants. The current landscape is dominated by these centralized entities, leading to what some describe as a “splinternet” where user data is siloed and controlled by corporations.

The History of the Solid Project: Reclaiming User Data

Sir Tim Berners-Lee, the visionary who gave us the World Wide Web, became increasingly concerned about the direction the web was taking. He envisioned a web where individuals, not corporations, owned and controlled their data. This concern led to the inception of the Solid project.

The Genesis of Solid

Solid, an acronym for “Social Linked Data,” was born out of Berners-Lee’s frustration with the centralized nature of Web 2.0. He saw a need to return to the web’s original principles of decentralization, openness, and user empowerment. The project officially began at MIT in 2015, with the goal of creating a platform that would allow users to store their data in personal online data stores (PODs) and grant applications permission to access specific pieces of that data.

Key Concepts of Solid

At its core, Solid proposes a fundamental shift in how data is managed on the internet.

  • PODs (Personal Online Data Stores): These are secure, personal data repositories where users store all their information – from social media posts and contacts to calendar events and health data. Users choose where their POD is hosted (e.g., on their own server, with a trusted provider).
  • Decentralization: Unlike Web 2.0 where data is scattered across numerous corporate servers, Solid centralizes data ownership with the individual. Applications access data from a user’s POD, rather than hosting it themselves.
  • Semantic Web Principles: Solid is deeply rooted in the principles of the Semantic Web. It leverages Linked Data, RDF (Resource Description Framework), and ontologies to ensure that data is not just stored but also meaningfully structured and interconnected. This allows different applications to understand and utilize the same data seamlessly, promoting interoperability.
  • Interoperability: Because data is stored in a standardized, semantic format within PODs, different applications can easily access and interpret the same data. A calendar application can read events from your POD, a social media app can access your contacts, and a health tracker can access your fitness data, all from the same source, with your explicit permission.
  • Fine-Grained Permissions: Users have complete control over who can access their data and to what extent. They can grant specific applications or individuals read, write, or append permissions for particular data points, ensuring privacy and security.

Early Development and Milestones

The initial stages of Solid involved developing the core specifications, protocols, and reference implementations. This included defining how PODs would function, how applications would interact with them, and how data would be structured using Semantic Web technologies. Early adopters and developers began experimenting with Solid, building prototypes and testing its capabilities. The project has seen continuous development and refinement, with contributions from a growing community of developers and researchers.

The Status Quo – Reaching Production

The Solid project has matured significantly since its inception and is now moving towards production-ready status. This involves not only refining the technical specifications but also building a robust ecosystem of applications and services.

Current State of Development

Solid’s core specifications are stable, and several implementations of Solid servers (POD providers) and client libraries are available. The community is actively working on improving developer tooling, documentation, and user experience.

Solid Pod Providers

A growing number of organizations and individuals are offering Solid POD hosting services. These range from self-hosted solutions for technically inclined users to managed services that simplify the process of setting up and maintaining a POD. This diversity ensures that users have options for where they store their data, promoting decentralization and resilience.

Emerging Solid Applications

Developers are increasingly building applications that leverage the Solid platform. These “Solid Apps” are designed to interact with users’ PODs, providing services without requiring users to hand over their data to the application provider. Examples include:

  • Social Networking Apps: Offering decentralized alternatives to existing social media platforms, where users own their profiles and connections.
  • Personal Organizers: Integrating calendars, to-do lists, and contacts from a single POD, accessible across various devices and applications.
  • Health and Fitness Trackers: Storing sensitive health data securely in a user’s POD, allowing users to share it with healthcare providers or fitness apps as they see fit.
  • E-commerce and Financial Tools: Enabling more secure and private online transactions by keeping personal financial data under the user’s control.

Challenges and Adoption

While Solid offers compelling benefits, its widespread adoption faces several challenges.

  • User Experience: For Solid to succeed, the user experience of managing PODs and granting permissions needs to be as intuitive, if not more so, than existing centralized services. Simplifying onboarding and interaction is crucial.
  • Developer Adoption: Encouraging developers to build Solid applications requires robust tooling, clear documentation, and a supportive community.
  • Network Effects: The “chicken and egg” problem exists – users need applications, and applications need users. Overcoming this requires strategic partnerships and a growing ecosystem.
  • Data Migration: Transitioning from existing centralized services to Solid PODs can be a complex process for users with large amounts of data. Tools and strategies for seamless data migration are essential.
  • Security and Trust: While Solid is designed with security in mind, ensuring the integrity and privacy of user data in a decentralized environment requires continuous vigilance and robust security measures. Building trust in the new paradigm is paramount.

Possibilities and Benefits: A New Era of the Web

The successful implementation and widespread adoption of Solid promise a transformative shift in the internet landscape, offering significant benefits for individuals, developers, and society as a whole.

Data Ownership and Privacy

The most profound benefit of Solid is the return of data ownership to the individual. Users gain complete control over their personal information, deciding where it’s stored and who can access it. This empowers individuals to make informed choices about their privacy and reduces the risk of data breaches and misuse by large corporations. It shifts the power dynamic from platforms to people.

Interoperability and Innovation

By leveraging Semantic Web principles, Solid fosters unprecedented interoperability. Data stored in a POD can be understood and utilized by any Solid-compatible application, regardless of its developer. This eliminates data silos and encourages innovation, as developers can focus on building powerful applications without having to worry about data ownership or compatibility issues with other platforms. New applications can easily integrate with existing data, leading to richer and more personalized experiences.

A More Competitive and Diverse Ecosystem

Solid breaks down the barriers to entry for new applications and services. Developers no longer need to build massive data infrastructure or rely on proprietary APIs. This fosters a more competitive and diverse ecosystem, where smaller teams and independent developers can create innovative solutions without being beholden to tech giants. This can lead to a resurgence of creativity and a wider array of choices for users.

Resilience and Censorship Resistance

A decentralized web is inherently more resilient. Data is not stored in a single, vulnerable location, making it less susceptible to outages, attacks, or censorship. If one POD provider goes offline, a user can simply move their POD to another provider, retaining full access to their data. This distributed nature enhances the stability and freedom of information on the internet.

Personalization and Contextual Experiences

With full control over their data, users can enable highly personalized experiences without sacrificing privacy. Applications can access specific data points (with explicit permission) to offer tailored recommendations, services, and content that are truly relevant to the individual. This moves beyond the generalized, often intrusive, personalization offered by current platforms.

The AI Charlie

Imagine an artificial intelligence agent, not controlled by a single corporation, but rather existing as a personal, intelligent assistant that draws its knowledge and capabilities from your own Solid POD. This is the intriguing concept of “AI Charlie.”

What is AI Charlie?

“AI Charlie” represents a hypothetical, personal AI that resides within or interacts directly with an individual’s Solid POD. Unlike current AI assistants that are tethered to large tech companies and learn from vast, aggregated datasets, AI Charlie would be an extension of you. It would learn from your personal data – your preferences, habits, communications, health data, and professional information – all stored securely and privately in your POD.

How Solid Enables AI Charlie

Solid’s architecture is perfectly suited for enabling such a personal AI:

  • Personalized Knowledge Base: Your Solid POD becomes AI Charlie’s primary knowledge base. It has access to your calendar, emails, documents, health records, social interactions, and browsing history (with your permission), allowing it to develop a deeply personal understanding of your needs and context.
  • Privacy by Design: Since all the data is in your POD, you control what AI Charlie can access and how it uses that information. This addresses many of the privacy concerns associated with current AI assistants. You can revoke access at any time.
  • Semantic Understanding: The Semantic Web foundation of Solid means that your data is not just raw information but structured and meaningful. AI Charlie can leverage this semantic richness to understand relationships between your data points, enabling more sophisticated reasoning and assistance. For example, if your calendar indicates a meeting with a specific person, AI Charlie could pull up relevant email conversations or documents from your POD related to that person.
  • Interoperability: AI Charlie could interact with other Solid applications and services, acting as a smart intermediary. It could, for instance, schedule appointments, manage tasks, research information, or even help you interact with decentralized financial services, all based on your personal data and preferences.

Potential Benefits of AI Charlie

  • True Personalization: AI Charlie could offer truly bespoke assistance, anticipating your needs and acting proactively based on your unique life context.
  • Enhanced Productivity: By intelligently managing your information and automating routine tasks, AI Charlie could significantly boost productivity.
  • Empowered Decision-Making: With access to all your relevant data, AI Charlie could provide comprehensive insights to help you make better decisions, from health choices to financial planning.
  • Digital Guardian: AI Charlie could act as a guardian of your digital life, identifying potential security threats, managing your online identity, and filtering information based on your preferences.

Challenges for AI Charlie

  • Development Complexity: Building an AI capable of understanding and reasoning over diverse personal data, while respecting privacy, is a significant technical challenge.
  • Ethical Considerations: Even with personal data ownership, ethical questions about AI autonomy, decision-making, and potential biases derived from personal data would need careful consideration.
  • User Interface: How users interact with and configure their AI Charlie, and how they define its boundaries and permissions, would be crucial for adoption.

The concept of AI Charlie pushes the boundaries of personalized computing, envisioning an AI that serves you exclusively, built on a foundation of data ownership and semantic understanding.

Conclusion

The Solid project represents a pivotal moment in the evolution of the internet. It is a bold and ambitious endeavor to reclaim the web’s original promise of decentralization, openness, and user empowerment. By putting individuals back in control of their data through Personal Online Data Stores and leveraging the power of the Semantic Web, Solid lays the groundwork for a more private, interoperable, and innovative digital future.

While challenges remain in terms of adoption, user experience, and the development of a thriving application ecosystem, the potential benefits are immense. Solid offers a compelling vision for an internet where data ownership is a fundamental right, where innovation flourishes unencumbered by centralized gatekeepers, and where concepts like “AI Charlie” can emerge, truly serving the individual. As we navigate an increasingly data-driven world, the principles championed by Solid offer a much-needed path towards a more equitable, resilient, and human-centric web. The journey to a decentralized web is ongoing, but Solid provides a robust framework and a beacon of hope for a better internet.

Die Solid-Challenge

/ configedit / Leave a comment

was ist Solid ?
nun, die schlechte Nachricht ist, um RDF werden Sie nicht herumkommen. die gute Nachricht ist, es gibt verschiedene Serialisierungen.

am MIT entstand (nach bestem Wissen und Gewissen) 2016 ein Linked Data System. ein Server. ein Framework, das Turtle benutzt. im weiteren Verlaufe – und die Entwicklung war parallel – entstand und erweiterte sich das Semantic Web. ein Webbetriebssystem funktioniert als Frontend, das Backend, wenn man so will, ist das Web. statische Daten in Triples organisiert. Daten und Anwendungen werden getrennt. Nein, dies ist nicht Medium und ich schreibe kein Howto. wir nennen es Solidverse.

  1. Die Daten befinden sich in einem Datastore, der um den jeweiligen User zentriert ist und der ausschliesslich Ihnen selbst gehört.
  2. Sie können ALLE Arten von Daten in Ihrem Pod speichern.
  3. Sie besitzen eine global einmalige ID, die den Schlüssel zum Solidverse darstellt.
  4. Sie benutzen einen Identity-Provider und einen Pod-Provider, die voneinander getrennt sein können, aber nicht müssen.
  5. Alle Apps müssen von Ihnen Consent einholen, also Sie um Erlaubnis fragen, ob sie mit Ihren Daten arbeiten dürfen. Dies kann auch auf Zeit geschehen.

Der Zufall, oder Gott, oder die Neugier, oder die Vorbildung, oder die Bubble, oder das Web, oder unbekannte Algorithmen haben entschieden, dass wir mittlerweile circa 15 Pod-Provider haben, die alle untereinander interoperabel sind. Unsere Herausforderung nun besteht darin, das ganze System so zu gestalten, dass ein Layman – also jeder – das System intuitiv bedienen kann.

Ein Profil anzulegen ist möglich. Applikationen gibt es, nun, eine erste Welle. das Ding nimmt langsam Fahrt auf. eine offizielle W3C-Arbeitsgruppe ist im Begriff, zu entstehen. Fitnessdaten, Schuhdaten, Urlaubsdaten, Heizungsdaten, Arztdaten, Bankdaten, Nachrichtendaten, Bilddaten, Like-Daten, Elektronikdaten, Gartendaten, Stromdaten, Musikdaten, Personaldaten, Verwaltungsdaten, Stringdaten, Integerdaten, Weltraumdaten, alles ist möglich. But how do we get Friction ?

Obwohl wir – eine absolute Zahl – bereits über 80.000 Accounts haben, wird wohl nur ein Bruchteil davon wirklich genutzt, und das wohl auch nur von technisch vorgebildeten Personen, technikaffinen also oder Nerds, Freaks, Techies. das Potential hingegen ist schwer absehbar, schier unendlich und wird das Web für immer verändern. Nicht über Nacht, aber drop for drop, Pod für Pod. das Protokoll ist funktionsfähig und bestens dokumentiert. Wechselwirkungen sind unvermeidbar.

5168 (imagine)

/ configedit / Leave a comment

Introduction

tags: solid intro

Solid is a standard. a protocol. a specification. a movement. a server. a project. a set of rules. a layer. an OS. a community. a site. a platform. a system. a method. a social thing. a thing. that’s it but it is more than the sum of all the parts.

timbl was worried about the direction, that his invention took. so we needed an update. the data should belong to their owners (the user) and not be kept in silos and walled gardens.

so what do you get ? a Webid and a Pod.

the webid is a simple URL (well it could be server.net/i)

the pod is your place on the web. a data storage.

let’s switch to mother tongue. imagine:

… Du brauchst Name, Adresse, Email, Login, bank account, phone, (von mir aus shoesize für den Schuhmacher) nur noch ein einziges Mal eingeben.

… Die Firmen (ja, alle) müssen DICH fragen, ob sie Deine Daten benutzen dürfen und Deine Daten (Fotos, Likes, Kommentare, Musik, Histories, Chats) werden zu Deinem Wohl arbeiten.

… Deine Apps werden interoperabel, das heisst App A versteht und spricht mit App B und wenn Dir App xyz nicht mehr gefällt, entziehst Du ihr die Rechte und benutzt stattdessen App lmn.

… Du kannst Deine Körper- und Fitnesswerte Deinem Arzt zur Verfügung stellen und er kann Dir die beste Therapie zur Verfügung stellen.

… Ein Ruck geht durchs Netz und Du brauchst nur noch ein einziges Login (früher Email, dann “mit Google, mit Twitter, etc.”) jetzt Login mit ID. [nun, in der Realität geschieht wahrscheinlich Folgendes]

… Hate Speech und Fake News wird ein Riegel vorgeschoben.

… Deine Computing-Power in der Hosentasche arbeitet 24/7 für Dich.

… wir verstehen uns und helfen uns untereinander.

… Diversity, Equity und Inclusion wird ein Topic.

Naiv, gewiss, aber wir arbeiten daran. lass mich noch 2 oder 3 Links anfügen.

solidproject.org solidservers.org solidweb.org

genug für den Moment, bald mehr, ausführlicher/detaillierter, und hoffentlich leicht verständlich. GOTO 10.

view raw Introduction.md hosted with ❤ by GitHub

4730 (autodidact pins down the progress)

/ configedit / Leave a comment

some more thoughts

  • NSS running 5.6.8
  • ^5.6.9 possibly needing node ^6.0 (resolved, use nvm)
  • CSS running 1.1.0
  • both on the same machine
  • a possible solution would be nvm
  • refactoring the auth-upgrade
  • new index.html template
  • auth-panel-meetings too much of it
  • wednesday SolidOS
  • umai and media-kraken working fine with CSS
  • webclip working fine with solidcommunity.net
  • databrowser needs an entry-point within its own context
  • monitor npmjs
view raw some more thoughts.md hosted with ❤ by GitHub

4470 (progress, workaround)

/ configedit / Leave a comment

Documentation SolidOS setup

  • normal shell user
  • install nvm
  • git clone
  • cd solidos
  • npm run setup
nvm is not compatible with the "PREFIX" environment variable: currently set to "/home/evemat/.nvm/versions/node/v15.5.0"
Run `unset PREFIX` to unset it.
npm ERR! code 11
npm ERR! path /home/evemat/Dokumente/development/solid/dev/solidos
npm ERR! command failed
npm ERR! command sh -c npm i && scripts/reset

npm ERR! A complete log of this run can be found in:
npm ERR!     /home/evemat/.npm/_logs/2021-02-14T04_00_41_639Z-debug.log
  • unset PREFIX
  • npm install says clean
  • cd workspaces/rdflib
  • npm run build
  • cd ../..
  • create mashlib/dist/databrowser.html
  • generate keys
  • put them in ./workspaces
  • export NODE_TLS_REJECT_UNAUTHORIZED=”0″
  • set chrome://flags/#allow-insecure-localhost
  • npm start
  • literally type h ttps://localhost:8443 (whitespace due to wordpress formatting readability)
lerna notice cli v3.22.1
lerna info versioning independent
lerna info Bootstrapping 5 packages
lerna info Symlinking packages and binaries
lerna success Bootstrapped 5 packages
  solid:settings Server URI: https://localhost:8443 +0ms
  solid:settings Auth method: oidc +4ms
  solid:settings Strict origins: true +0ms
  solid:settings Allowed origins:  +0ms
  solid:settings Db path: ./.db +0ms
  solid:settings Config path: ./config +1ms
  solid:settings Suffix Acl: undefined +0ms
  solid:settings Suffix Meta: undefined +0ms
  solid:settings Allow WebID authentication: true +0ms
  solid:settings Live-updates: true +0ms
  solid:settings Multi-user: true +0ms
  solid:settings Suppress default data browser app: undefined +1ms
  solid:settings Default data browser app file path: default +0ms
  solid:settings CORS proxy listening at /proxy?uri={uri} +21ms
  solid:settings Base URL (--mount): / +20ms
  solid:settings SSL Private Key path: ../privkey.pem +0ms
  solid:settings SSL Certificate path: ../fullchain.pem +1ms
Solid server (v5.6.4-3-g1afe2f45) running on https://localhost:8443/
Press <ctrl>+c to stop
  solid:authentication Provider keys loaded from config +0ms
  solid:authentication Provider keychain initialized +72ms
  solid:authentication Not sleeping before client registration... +2ms
  solid:authentication Client not present for issuer https://localhost:8443, initializing new client +3ms
  solid:authentication Registering new client for issuer  https://localhost:8443 +1ms
  solid:authentication Local RP client initialized +306ms
  • working !
view raw Documentation SolidOS setup.md hosted with ❤ by GitHub

4237 (solidweb.org running)

/ configedit / Leave a comment

solidweb.org

solidweb.org


—-
https://solidweb.org
—-

Documentation solidweb.org install

  • install environment (Debian 10, https://kis.hosteurope.de)
  • change and note password (Kundenadmin)
  • ssh into the machine as root
  • apt-get update
  • apt-get upgrade
  • apt-get install curl nano nginx
  • systemctl stop apache2
  • systemctl start nginx
  • adduser --system --ingroup www-data --no-create-home solid
  • wget https://dl.eff.org/certbot-auto (deprecated, should be replaced by certbot)
  • mv certbot-auto /usr/local/bin/certbot-auto
  • chown root /usr/local/bin/certbot-auto
  • chmod 755 /usr/local/bin/certbot-auto
  • cd /usr/local/bin/
  • ./certbot-auto certonly \ --manual \ --preferred-challenges=dns \ --email evemat@web.de \ --server https://acme-v02.api.letsencrypt.org/directory \ --agree-tos \ -d solidweb.org -d *.solidweb.org
  • DNS-Challenge
  • chmod -R 755 /etc/letsencrypt/live/ /etc/letsencrypt/archive/
  • curl -sL https://deb.nodesource.com/setup_16.x | sudo bash -
  • apt-get install nodejs
  • node -v
  • npm -v
  • npm install -g solid-server
  • solid init
$ solid init
* ? Path to the folder you want to serve. Default is (./data) /var/www/html/data
? SSL port to run on. Default is (8443) 8443
? Solid server uri (with protocol, hostname and port) https://solidweb.org
? Enable WebID authentication Yes
? Serve Solid on URL path /
? Path to the config directory (for example: /etc/solid-server) (./config) /var/www/html/config
? Path to the config file (for example: ./config.json) (./config.json) /var/www/html/config.json
? Path to the server metadata db directory (for users/apps etc) (./.db) /var/www/html/.db
? Path to the SSL private key in PEM format /etc/letsencrypt/archive/solidweb.org/privkey1.pem
? Path to the SSL certificate key in PEM format /etc/letsencrypt/archive/solidweb.org/fullchain1.pem
? Enable multi-user mode Yes
? Do you want to set up an email service (y/N) N
? A name for your server (not required) solidweb.org
? A description of your server (not requred) undefined
? A logo (not required) undefined
? Do you want to enforce Terms & Conditions for your service (y/N) N
? Do you want to disable password strength checking (y/N) N
? The support email you provide for your users (not required) meisdata@gmail.com
config created on /root/config.json

"useEmail": true, "email": { "host": "smtp.sendgrid.net", "port": "465", "sender": "me@evering.eu", "secure": true, "auth": { "user": "apikey", "pass": "xxxxxx" } }

  • copy to /var/www/html/config.json
  • create /lib/systemd/system/solid.service
[Unit]
Description=solid - Social Linked Data
Documentation=https://solid.inrupt.com/docs/
After=network.target

[Service]
Type=simple
User=solid
WorkingDirectory=/var/www/html
ExecStart=/usr/bin/solid start
Restart=on-failure

[Install]
WantedBy=multi-user.target
  • ln -s /lib/systemd/system/solid.service /etc/systemd/system/multi-user.target.wants/
  • chown solid:www-data /var/www/html/config.json
  • cd /var/www/html
  • chown -R solid:www-data config data .db
  • create /etc/nginx/sites-available/default
# Nginx configuration for Solid on Port 8443

## Redirects all HTTP traffic to the HTTPS host
server {
  ## In case of conflict, either remove "default_server" from the listen line below,
  ## or delete the /etc/nginx/sites-enabled/default file.
  listen 0.0.0.0:80;
  listen [::]:80;
  server_name solidweb.org;
  server_tokens off; ## Don't show the nginx version number, a security best practice
  return 301 https://$http_host$request_uri;
  access_log  /var/log/nginx/solid_access.log;
  error_log   /var/log/nginx/solid_error.log;
}

server {
  listen *:443 ssl;
  listen [::]:443 ssl;
  server_name solidweb.org;
  server_tokens off;

  access_log  /var/log/nginx/solid_ssl_access.log;
  error_log   /var/log/nginx/solid_ssl_error.log;

ssl_certificate /etc/letsencrypt/archive/solidweb.org/fullchain1.pem;
ssl_certificate_key /etc/letsencrypt/archive/solidweb.org/privkey1.pem;

root /var/www/html; #webroot

  ## [Optional] Enable HTTP Strict Transport Security
  ## HSTS is a feature improving protection against MITM attacks
  ## For more information see: https://www.nginx.com/blog/http-strict-transport-security-hsts-and-nginx/
  add_header Strict-Transport-Security "max-age=31536000; includeSubDomains";

  location / {
    proxy_pass https://localhost:8443;

    gzip off;
    proxy_redirect off;

    ## Some requests take more than 30 seconds.
    proxy_read_timeout      300;
    proxy_connect_timeout   300;
    proxy_redirect          off;

    proxy_http_version 1.1;

    proxy_set_header    Host                $http_host;
    proxy_set_header    X-Real-IP           $remote_addr;
    proxy_set_header    X-Forwarded-Ssl     on;
    proxy_set_header    X-Forwarded-For     $proxy_add_x_forwarded_for;
    proxy_set_header    X-Forwarded-Proto   $scheme;
    
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
  }

}
  • systemctl restart nginx
  • nano /var/www/html/config/templates/new-account/settings/serverSide.ttl
@prefix dct: <http://purl.org/dc/terms/>.
@prefix pim: <http://www.w3.org/ns/pim/space#>.
@prefix solid: <http://www.w3.org/ns/solid/terms#>.

<>
  a pim:ConfigurationFile;

  dct:description "Administrative settings for the POD that the user can only read." .

</>
    solid:storageQuota "250000000" .
  • systemctl start solid.service
view raw Documentation solidweb.org install.md hosted with ❤ by GitHub

4187 (services.json)

/ configedit / Leave a comment 
{
	"idps": [
		{
			"url": "https://inrupt.net/",
			"icon": "https://inrupt.com/themes/custom/solid/logo.svg",
			"icon_bg": "#ffffff",
			"title": "inrupt.net",
			"title_color": "#fff",
			"policyURL": "https://inrupt.net",
			"description": "inrupt.net is a public server provided by Inrupt, Inc.",
			"btn_bg": "#43C47A",
			"btn_color": "#fff"
		},
		{
			"url": "https://solid.community/",
			"icon": "https://solid.inrupt.com/themes/custom/solid/logo.svg",
			"icon_bg": "#333748",
			"title": "solid.community",
			"title_color": "#fff",
			"policyURL": "https://solid.community",
			"description": "solid.community is a public server for early adopters of Solid.",
			"btn_bg": "#43C47A",
			"btn_color": "#fff"
		},
		{
			"url": "https://dev.inrupt.net/",
			"icon": "https://solid.inrupt.com/themes/custom/solid/logo.svg",
			"icon_bg": "#333748",
			"title": "dev.inrupt.net",
			"title_color": "#fff",
			"policyURL": "https://inrupt.net",
			"description": "dev.inrupt.net is a public development Server of Inrupt, Inc.",
			"btn_bg": "#43C47A",
			"btn_color": "#fff"
		},
		{
			"url": "https://solidweb.org/",
			"icon": "https://www.serverproject.de/logo2.png",
			"icon_bg": "#333748",
			"title": "solidweb.org",
			"title_color": "#fff",
			"policyURL": "https://www.serverproject.de/files/solidweb_org_terms.txt",
			"description": "solidweb.org is a public Solid server based in Germany which is in an experimental state.",
			"btn_bg": "#43C47A",
			"btn_color": "#fff"
		},
		{
			"url": "https://solid.authing.cn/",
			"icon": "https://usercontents.authing.cn/client/logo@2.png",
			"icon_bg": "#333748",
			"title": "solid.authing",
			"title_color": "#fff",
			"policyURL": "https://solid.authing.cn",
			"description": "solid.authing is a public solid server deployed in China",
			"btn_bg": "#43C47A",
			"btn_color": "#fff"
		},
		{
			"url": "https://solid.open.ac.uk/",
			"icon": "https://www.liberaldictionary.com/wp-content/uploads/2018/12/open-university.png",
			"icon_bg": "#333748",
			"title": "solid.open.ac.uk",
			"title_color": "#fff",
			"policyURL": "http://www.open.ac.uk",
			"description": "solid.open.ac.uk is a public Solid server based in the UK.",
			"btn_bg": "#43C47A",
			"btn_color": "#fff"
		}
		
	]
}